Java中类和对象

面向对象的认识

前言
何为面向对象何为面向过程呢？，C语言是最经典的面向过程的语言,但是C语言虽然可以解决一定的问题，但是在解决复杂的问题的时候，这时候编写会变得有些困难。这时候就要引出了面向对象语言的出现。

---

面向对象的定义

⾯向对象是解决问题的⼀种思想，主要依靠对象之间的交互完成⼀件事情。使用面向对象的方式更符合人的思考，尤其是对大型程序的设计、扩展和维护很好
Java就是一个面向对象的语言，在面向对象的世界，一切皆为对象

面向对象和面向过程都有自己的有优缺点，根据具体场景来进行进行使用

类的定义和使用

1 类的定义

在面向对象的语言中一切皆为对象，比如：生活中我们的电脑，我们并不需要关心其内部如何运行的，只需要关系如何使用电视机就行。
类是用来对一个实体进行描述的
例如：电脑
属性：颜色、品牌、大小、价格等等
功能：放视频、打字、玩游戏
这个电脑就像是一个类，会有一些属性和功能

2 类的创建

Java中创建需要使用到class关键字

class ClassName{ 
    field; // 字段(属性) 或者 成员变量 
    method; // ⾏为 或者 成员⽅法 
}

这里的ClassName就是类的名称，整个大括号就是类的全部
这里的field是类的成员变量,这里的method就是类的成员方法，相当于有哪些东西，有哪些功能
例如：

public class Computer {
    public String cpu; // cpu
    public String memory; // 内存
    //被private修饰后只可以在这个类中使用
    public String screen; // 屏幕

    public void movie(){
        System.out.println("放视频");
    }
    public void game(){
        System.out.println("玩游戏");
    }
}

这样我们就创建好了一个类
注意事项：我们创建的时候类名采用大驼峰
这里定义类的方法和以前的同一个类中定义的方法有所不同这里没有stastic
类的名称和文件名相同

3 类的实例化

类相当于我们自己创造了一个新的类型，就像Java自带的int double等等自带的类型，
那我们如何使用这个类呢？

public class Dog{
    public String name;
    public int age;

    public void eat(){
        System.out.println(name+"吃饭");
    }

}

上面我们创建了一个Dog类
我们用类的类型来创建对象的过程，这就成为类的实例化，这里Java需要使用new关键字，来创建
例如：我们使用上面的Dog类来进行创建（两个放在不同的文件夹）

public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        Dog dog1 = new Dog();
         dog.age = 3;//初始化
        System.out.println(dog.age);
        System.out.println(dog.name);
    }
}

运行结果如下

我们发现一个问题，这里我们创建了Dog类型的变量，但是我们没有初始化，为什么没有出错呢，那是因为类中如果没有初始化，他们会默认初始化，就像Java中的数组一样

类型	默认值
byte	0
short	0
int	0
long	0
float	0.0f
double	0.00
char	/u000
boolean	false
String	null

new来实例化对象
. 来访问类的变量 /方法
一个类可以实例化多个对象
实例化出的对象占⽤实际的物理空间，存储类成员变量

构造方法

1 构造方法的概念

构造⽅法(也称为构造器)是⼀个特殊的成员⽅法，名字必须与类名相同，在创建对象时，由编译器⾃动调⽤，并且在整个对象的⽣命周期内只调⽤⼀次。

class Date{
    public int year;
    public int month;
    public int day;
    //方法
    public void date(int year,int month ,int day){
        this.year = year;
        this.month = month;
        this.day = day;
        System.out.println("方法被执行了");
    }
    //构造方法
    public Date(int year,int month,int day){
        this.year = year;
        this.month = month;
        this.day = day;
        System.out.println("构造方法被执行了");
    }
    public void printdate(){
        System.out.println(year+"/"+month+"/"+day);
    }
    public static void main(String[] args) {
        Date date1 = new Date(2000,3,12);


        date1.date(2000,3,21);
        date1.printdate();
    }
}

运行结果如下
可以看出这里的构造方法是在创建一个新对象的同时，进行了传递，后面又调用了方法，构造方法中的值被方法覆盖了

构造方法与类的方法的区别

2 构造方法的注意事项

1 构造方法名字必须与类名相同，没有返回值类型
例如：我们以上面的Date类进行举例

这时候我们Date的构造方法有了void返回类型，编译器就会报错，不可以有类型

2 创建对象的同时编译器会自动调用构造方法，这里参数要和构造方法大小和类型相同，并且一个对象只会调用一次构造类型

上面我们创建一个Date类型的话，我们在new新对象的时候必须和Date传参保持一致否则会报错
就像下面这样会报错

但是我们发现一个问题，我们在new新对象的时候都要引用构造类型，但是以前我们并没有编写Date构造方法，然而并没有报错为什么呢？

是因为以前我们没有编写构造方法，编译器会给我们生成一个默认没有参数的构造方法，这样我们在new新的对象的时候没有报错
那为什么上面我们调用不带参数的为什么报错了呢，不是说编译器会帮我们写吗，这是因为如果我们已经写了构造方法编译器就不会默认生成不带参数的了，上面这样的必须和编写的构造方法参数一致
我们即想要无参类型又想要有参类型，该怎么做呢
3 构造方法构成重载，构造方法也可以像普通的方法一样构成重载

class Date{
    public int year;
    public int month;
    public int day;
    //构造方法

    public  Date(int year,int month,int day){
        this.year = year;
        this.month = month;
        this.day = day;
        System.out.println("三个参数构造方法被执行了");
    }
    public Date(){
        System.out.println("无参的构造方法被执行");
    }
    public Date(int year){
        this.year = year;
        System.out.println("一个参数的构造方法被执行");
    }
    public void printdate(){
        System.out.println(year+"/"+month+"/"+day);
    }
    public static void main(String[] args) {
        Date date1 = new Date();//无参

        Date date2 = new Date(2000,3,21);//3个参数

        Date date3 = new Date(2000);//一个参数

    }
}

从上面我们可以看出，这里构成了重载，不同的进入了不同的构造方法，这样我们可以自己创建需要几个对象的构造方法，直接调用就行

构造方法的名称与类名必须相同
构造方法没有返回类型
构造方法只在new创建一个新的对象的时候进行调用
构造方法可以构成重载

this关键字

this关键字的使用

this.成员变量 //访问对象的成员变量 
this.成员⽅法 //访问对象的成员⽅法 
this(参数列表)//类中调用类的构造方法

public class Date{
    public int year;
    public int month;
    public int day;
    //方法
    public void date(int year,int month ,int day){
        this.year = year;
        this.month = month;
        this.day = day;
        //this访问成员方法
        this.printdate();
    }

    public void printdate(){
        System.out.println(year+"/"+month+"/"+day);
    }
    public static void main(String[] args) {
        Date date1 = new Date();
        Date date2 = new Date();

        date1.date(2000,3,21);
    }
}

运行结果如下
这里我们使用this调用的成员方法

如果把this关键字去掉的话，并且这里的形参和实参相同，我们会发现一个问题，这里的传参好像并没有传进去
这里的还是类中默认值0 这里是因为是将类中的数据对应赋值，并不是我们所传入的参数
所以这里相当于 给他们都赋值为 0默认值

this引⽤指向当前对象(成员⽅法运⾏时调⽤该成员⽅法的对象)，在成员⽅法中所有成员变量的操作，都是通过该引⽤去访问

        this.year = year;
        this.month = month;
        this.day = day;
        这样的话就可以正常的赋值了，是因为这里表示的是当前对像被引用

this只能在类的方法中使用

像这样就是错误的使用this，this不可以在类外使用，只能在类中方法中使用

this访问构造方法

public class Date{
    public int year;
    public int month;
    public int day;
    //方法
    public Date(){
    //调用三个参数的构造方法
        this(2000,3,11);
    }
    public Date(int year,int month ,int day){
        this.year = year;
        this.month = month;
        this.day = day;
        //this访问成员方法
        this.printdate();
    }

    public void printdate(){
        System.out.println(year+"/"+month+"/"+day);
    }
    public static void main(String[] args) {
        Date date1 = new Date();

    }
}

运行结果如下
这样我们可以在Date方法调用三个参数的构造方法

但是我们要注意这里的this语句要放在第一行
如果不放在第一行就会报错

把this放在第一行就不会报错了

this的类型：对应类类型引⽤，即哪个对象调⽤就是哪个对象的引⽤类型
this只能在"成员⽅法"中使⽤在，只能引用当前对象
this如果引用类中的构造类型必须放在第一句
this不可以在类外使用

到这里就结束了，希望对大家有所帮助，欲知后事如何，请听下回分解