java面向对象（重点）构造方法和构造代码块

面向对象通过两个概念来描述    先有类，再有对象

类和对象

类是对一切相似事物的统称，是一个广泛的概念，用来描述类的属性和特征的

属性是静的，使用java变量来描述  

行为是动的，使用方法来描述  先不使用Static

人的属性是：名字  年龄  体重  性别

人的行为是：

类的语法格式：

class 类名  {

用来描述当前类的属性

用来描述当前类的行为

 }

狗	动物类
人	人类
风扇	电器类

对象：是真实存在的值，是在类基础之上孵化出来的，可以调用类的属性和行为。

对象的语法格式：类名  对象的名字 = new  类名（）；

可以使用对象调用类的属性和方法

class Person{
    //当前类描述类的属性  使用java变量来描述
    String name;
    int age;
    //用来描述当前类的方法
    public void eat(){
        System.out.println("在方法中先不使用Static");
    }
    public void sleep(){
        System.out.println("在睡觉");
    }
}

public class Demo4{
    public static void main(String[] args) {
    //创建对象  类名  对象的名字 = new  类名（）；
        Person person = new Person();
        //对象是真实存在的值，在类基础之上孵化出来的，可以调用类的属性和方法
        person.name="人类";
        person.age=20;
        //调用方法  对象.方法的名字
        person.eat();
        person.sleep();
        //取值
        System.out.println(person.age);
        System.out.println(person.name);
    }
}

 创建一个dog类，可以在对象中有多个dog

class Dog{
    //用来描述类的属性
    String name;
    int age;
    double weight;
    //用来描述类的行为
    public void eat(){
        System.out.println("人在吃饭");
    }
    public void sleep(){
        System.out.println("在睡觉");
    }
}
public class Demo4{
    public static void main(String[] args) {
    //创建对象  类名  对象的名字 = new  类名（）;
        Dog dog = new Dog();
        dog.name="小狗";
        dog.age=3;
        System.out.println(dog.name+"\n"+dog.age);
        //调用方法  对象.方法的名字
        dog.eat();
        dog.sleep();


        Dog dog1 = new Dog();
        dog1.name="sange";
        dog1.age=2;
        dog1.eat();
        dog1.sleep();
        System.out.println(dog1.age);
        System.out.println(dog1.name);
    }
}

创建的实体类和测试类在同一个Java文件中

文件的名字以测试类来命名

注意事项：实体类和测试类写在同一个类的时候，实体类不可以使用public修饰类

class Pig{
    //文件类和测试类写在同一个类的时候，实体类中不能带public修饰符
    String name;
    int age;
    double weight;
    
    //方法
    public void eat(){
        System.out.println("在吃饭");
    }
    public void sleep(){
        System.out.println("在睡觉");
    }
}
public class Demo4{
    public static void main(String[] args) {
        //创建对象  可以调用类的属性和行为的
        Pig pig = new Pig();
        pig.name="小猪";
        pig.weight=100.0;
        pig.age=3;
        pig.eat();
        pig.sleep();
        System.out.println(pig.name);
        System.out.println(pig.age);
        System.out.println(pig.weight);
    }
}

构造方法：是为了初始化类对象的，可以对属性进行赋值的，对象的创建其实是依据构造方法来创建的。

class Dog{
    String name;
    int age;

    public Dog(){
        System.out.println("这是无参构造");
        this.name="小狗";
        this.age=22;
    }
}
public class Demo4{
    public static void main(String[] args) {
      //创建对象 可以调用类的属性和方法
        Dog dog = new Dog();
        //打印出来的是小沟和87  为什么不是小狗 22  因为无参构造比后面的先执行，所以会被覆盖掉
        dog.name="小沟";
        dog.age=87;
        System.out.println(dog.name);
        System.out.println(dog.age);
    }
}

有参构造：

class Monkey{
    String name;
    int age;
    double weight;

    public Monkey(){
        System.out.println("嘻嘻哒");
    }
    public Monkey(String name,int age,double weight){
        this.name=name;
        this.age=age;
        this.weight=weight;
        System.out.println("哈哈大");
    }
    public void eat(){
        System.out.println("吃饭");
    }
    public void sleep(){
        System.out.println("在睡觉");
    }
}
public class Demo4{
    public static void main(String[] args) {
        //当new 对象的时候，会自动调用构造方法，执行构造方法里的方法体
        Monkey monkey  = new Monkey("小猴子",34,22.2);
        System.out.println(monkey.name);
        System.out.println(monkey.age);
        //调用用方法
        monkey.eat();
        monkey.sleep();
    }
}

构造代码块：目的是为了初始化类对象的，可以对属性进行赋值的

构造代码块和构造方法的区别是什么？

构造法代块比构造方法先执行    

先执行构造代码块，在执行构造方法

class Tiger{
    String name;
    int age;

    {
        this.name="小猫";
        System.out.println("构造代码块");
    }
    public Tiger(){

    }
}
public class Demo4{
    public static void main(String[] args) {
        Tiger tiger = new Tiger();
        //构造代码块比构造方法先执行   先执行构造代码块  在执行构造方法
        System.out.println(tiger.name);
        System.out.println(tiger.age);
    }
}

class Dog{
    String name;
    int age;
    
    //这是构造方法
    public Dog(){
        this.name="兄狗";
        this.age = 3;
        System.out.println("这是构造方法");
    }
    //这是构造代码块
    {
        this.age=33;
        this.name="xiaf";
        System.out.println("这是构造代码块");
    }
}
public class Demo4{
    public static void main(String[] args) {
        Dog dog = new Dog();
        //先执行实体类中的构造代码块，在执行构造方法 结果为这是构造代码块  这是构造方法  兄狗  3
        System.out.println(dog.name);
        System.out.println(dog.age);
    }
}