类和对象定义以及四种初始化方式

对象是真正存在的实体，是具体的事物
类是对实体的一种抽象，也可以看做是一种模板，对象则是使用模板制造的多个实物

我们如果把人看做是一个类（Person）
那么人有他自己的名字，年龄，性别等，这些是人的属性
但是人也可以吃饭，睡觉，玩游戏等，有许多动作，这些是所谓的方法

那么我们如何来定义一个类？

class Person{
    private String name;
    private int age;
    private String sex;
    }

这里我们定义了个类（Person），人有名字，年龄，性别，所以我们在这里定义了他的这些属性
为什么要在定义前加上private呢？
是因为为了保证我们代码的安全性，完整性，让这些属性私有化，不让外界的任何人可以进行访问
当然我们除了属性外，还有一些行为，我们在这里称之为方法，像我们人可以吃喝玩，所以我们可以向其中添加这些方法

class Person{
    private String name;
    private int age;
    private String sex;  
    public void eat(){
        System.out.println("Person eat!!");
    }
    public void sleep(){
        System.out.println("Person sleep!!!");
    }
}

像上面的代码中吃和睡都是人的一种行为，但是我们将其称为实例成员的方法或者函数
那么我们也可以在类中写一个静态的方法，显然也是可以的

public static void drink(){
    System.out.println("Person  drink");
    }
    public void show(){
    System.out.println("name: "+name+"age: "+age+"sex"+sex);
    }

当我们创建好了一个类，就需要实例化一个对象

public static void main(String[] args) {
        Person p1 = new Person();
        }

这里的p1就是引用变量对象，那么所创建的p1和我们的属性是怎么存储的呢？

如果我们没有给类中的名字，年龄这些属性赋值的话，那么会输出什么呢？
我在之前代码中写了一个show（）函数，那么我们如果想要调用该函数/方法，我们需要通过对象名.方法这种方式来进行访问

public static void main(String[] args) {
        Person p1 = new Person();
        p1.show();
    }

输出结果为

name: null age: 0  sex: null

可以看出是其类型相对应的默认值
那么boolean的默认值为false
char类型的默认值为\u0000

值得注意的是，当我们想要访问drink（）方法时，我们知道它定义的是一个静态的方法，我们输入p1.drink();进行访问时会出现警告，但是可以进行访问，那么我们如何来消除此警告呢？
我们需要通过类名.方法进行访问即可消除警告
即Person.drink();

那么我们如何给class中定义的年龄这些赋值呢？
可以直接通过对象来赋值

public static void main(String[] args) {
        Person p1 = new Person();
        p1.show();
        System.out.println("======赋值后========");
        p1.drink();
        p1.age = 21;
        p1.name = ("Jack");
        p1.sex = ("男");
        p1.show();

    }

输出结果为

name: null age: 0  sex: null
======赋值后========
Person  drink
name: Jack age: 21  sex: 男

需要注意的是当我们定义时name是private String name 此时我们通过对象.方法是无法进行赋值的，会报错是因为其是私有的。

初始化还有一种方式是通过提供一系列的get和set方法来进行初始化

 public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }

我们利用这个方法也可以访问类中的数据，如访问name

public static void main(String[] args) {
        Person p1 = new Person();
        p1.show();
        System.out.println("======赋值后========");
        p1.getName();
        p1.setName("Jenny");
        p1.show();

    }

输出为：

name: null age: 0  sex: null
======赋值后========
name: Jenny age: 0  sex: null

可以看到名字改成了“Jenny”；那么如何快速的建立get和set方法呢？
我们可以在代码空白处点击鼠标右键中找到该按键

可以自动创建set和get方法

p1.getName();//获取对象p1中name的值
p1.setName("Jenny");//将Jenny赋值给p1对象中的name

我们也可以通过构造方法来实现初始化
现在我在calss Person{}中创建了两个新的构造函数

 public Person(){
        this.name = "Mary";
        this.age = 18;
        this.sex = "女";
    }
    public Person(String name,int age,String sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

值得注意一点的是我们两个方法用的都是类名Person()
但是没有报错是因为什么呢？
构造方法的重载
什么是构造方法的重载？
需要满足三个条件：
1.方法名相同
2.返回值相同
3.参数列表不同

那么我们在访问的时候如果访问第一个默认构造函数和第二个有参数的构造函数有什么不同呢？

public static void main(String[] args) {
        Person p1 = new Person();
        p1.show();
        System.out.println("======赋值后========");
        Person p2 = new Person("Lucy",19,"女");
        p2.show();
        }

输出为：

name: Mary age: 18  sex: 女
======赋值后========
name: Lucy age: 19  sex: 女

其中this引用：指向当前对象的内存并不是调用该方法的对象

若我们写下如下的代码

 public Person(){
        this("Mike",25,"男")；
        System.out.println("Peroson init");     
    }
    public Person(String name,int age,String sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
        System.out.println("Peroson(String,int,String)");
    }

当我们运行时会发现结果是这样的：

Peroson(String,int,String)
Peroson init
name: Mike age: 25  sex: 男

所以呢，可以看出是调用了带有三个参数的构造函数
如果有显示的构造函数，就不会调用默认的构造函数
且 this(“Mike”,25,”男”)； 必须放在第一行的位置上，否则会报错，如

public Person(){

        System.out.println("Peroson init"); 
        this("Mike",25,"男");//error
    }

对象的创建我们分为两步：
1.为对象分配内存
2.调用合适的构造函数

我们也可以采用实例代码块进行初始化，直接在Person类中加入实例代码块

class Person{
    String name;
    int age;
    String sex;
    {
        name = "Faker";
        age = 18;
        sex = "男";
    }

运行结果如下：

name: Faker age: 18  sex: 男

当然我们也可以使用静态代码块来进行初始化
静态变量是被所有实例共享的
类被加载时，静态代码块会执行，由于类只加载一次，因静态代码块只加载一次

  static{
        System.out.println("静态代码块初始化");
        data = data2 +10;
        }

且static修饰的会在类实例化之前全部进行初始化

那么我们的初始化程序的顺序是什么呢？

class Person{
    String name;
    int age;
    String sex;
    public static int data = 10;
    public static final int data2 = 20;
    static{
        System.out.println("静态代码块初始化");
        data = data2 +10;
    }
    {
        System.out.println("实例代码块初始化");
    }
    public void eat(){
        int data1 = 10;
        int data3;
        data3 = data1 + 10;
        System.out.println(data3);
        System.out.println("Person eat!!");
    }
    public void show(){
    System.out.println("name: "+name+" age: "+age+"  sex: "+sex+" data: "+data);
    }
    public Person(){
        this("Mike",25,"男");
        System.out.println("Peroson init");     
    }
    public Person(String name,int age,String sex){
        this.name = name;
        this.age = age;
        this.sex = sex;
        System.out.println("Peroson(String,int,String)");
    }
}
public class TestDemo1 {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.show();   

    }   
}

输出为：

静态代码块初始化
实例代码块初始化
Peroson(String,int,String)
Peroson init
name: Mike age: 25  sex: 男 data: 30

可以看出静态代码块初始化>实例代码块初始化>构造函数