Java第八课_构造和静态

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 + '\'' +
                  '}';
      }
  }