Java第八课_构造和静态-526互联

2.面向对象的编程

构造

public class Practice {
    public static void main(String[] args) {
        Person person1 = new Person();
        Person person2 = new Person("lisi");
        Person person3 = new Person("哪吒", 3);
    }
}

public class Person {

    private String name;
    private int age;

    /*
        参数不同的构造器,里面可能有重复的初始化内容.可以使用this()构造器,和构造代码块.
            1.this :通过 this() 进行构造器的调用
                a.this() 必须位于构造器的第一条语句的位置
                b.当有n个构造器时,this() 最多有n-1个  1.可能会出现递归
            2.构造代码块{}
                a.为所有对象初始化. 特点 : 在每次使用 new 关键字创建对象时,先于构造器执行一次
                b.在对象初始化时执行一次.只会执行一次,不会因为this()调用构造器,而反复执行
                c.可以有多个构造代码块`
     */

    {
        System.out.println("我是构造代码块!");
        cry();
    }

    {
        System.out.println("123");
    }

    public Person() {
    }

    public Person(String name) {
        this();
        this.name = name;
    }

    public Person(String name, int age) {
        this(name);
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void cry(){
        System.out.println("555555555555555");
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

静态

public class Practice {
      /*
          程序在执行时的顺序和空间
          A a = new A() ;

          1.加载 A.class 文件到内存中 , 所有静态成员随之一起加载. 静态变量存在, 静态构造执行
          2.在堆内存中开辟空间,存放实际对象的值
          3.成员变量默认初始化
          4.成员变量显式初始化
          5.构造代码块初始化
          6.构造器初始化
          7.堆内存分配地址
          8.将堆内存分配的地址存入栈内存中的区域,初始化结束
    */

    public static void main(String[] args) {
        Student s1 = new Student("ls", 20);
        Student s2 = new Student("zs", 21);

        System.out.println("s1 = " + s1);
        System.out.println("s2 = " + s2);

        s1.country = "华夏";

        System.out.println(s2.country);

        Student.country = "中华";

        System.out.println(s1.country);

        Practice test01 = new Practice();
        test01.m1();
    }

    public void m1(){
        System.out.println("F");
    }
}

public class Student {
    /*
         static : 表示静态的 , 是一个修饰符
         特点 :
            1.static修饰的成员是随字节码文件一起加载的,也就是 静态成员 没有实际对象时就已经存在
            2.static修饰是共享数据. 当某一个类的变量基本不变时, 用static修饰, 只会在方法区占用一块内存, 所有对象共享
            3.访问方式多了一种 : 类名.成员名    开发推荐方式
        缺点 :
            1.访问出现局限性 : 静态的只能访问静态的,不能访问非静态的 ; 非静态成员可以访问静态成员
            2.生命周期过长 :

        静态变量又称为类变量
        变量: 当变量是共享数据时,就可以使用 static 修饰
        函数: 当函数没有调用非静态成员时,就可以使用static修饰
     */

    String name;
    int age;
    static String country = "CN";

    // 静态代码块: 为静态成员初始化 特点 : 只在加载字节码文件时加载一次
    static {
        System.out.println("A我是静态构造代码块!");
    }

    {
        System.out.println("B我是构造代码块!");
    }

    public Student() {
        System.out.println("C");
    }

    public Student(String name, int age) {
        System.out.println("D");
        this.name = name;
        this.age = age;
    }

    public static void m1(){
        System.out.println("E");
    }

    public static void show(){
        System.out.println("country = " + country);
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", country='" + country + '\'' +
                '}';
    }
}