【P373java类变量的引出-P390java代码块的细节】

P373java类变量的引出-P390java代码块的细节

package com.work;
public class ChildGame {
    public static void main(String[] args) {
        //定义一个变量count, 统计有多少小孩加入了游戏
        int count = 0;
        Child child1 = new Child("白骨精");
        child1.join();
        child1.count++;
        //类变量，可以通过类名来访问
        System.out.println("共有" + Child.count + " 小孩加入了游戏...");
    }
}
class Child{
    private String name;
    public static int count=0;
    //定义一个变量count,是一个类变量(静态变量) static 静态
    //该变量最大的特点就是会被Child 类的所有的对象实例共享
    public Child(String name) {
        this.name = name;
    }
    public void join() {
        System.out.println(name + " 加入了游戏..");
    }
}

-

当在类加载的时候在堆里生成类的对象，jd8以前以为在方法区，后面在堆里

（static变量保存在class实例的尾部，class对象在堆中）

总结：

P377java类变量定义

P378类变量细节

-

P379类方法

-

P383main方法

-  

执行这个程序的时候，传入参数会形成数组（DOS命令加上 java Hello 参数1 to 参数n)P382

P384动态传值

package com;
​
public class Main02 {
    public static void main(String[] args) {
        for (int i = 0; i < args.length; i++) {
            System.out.println("args["+i+"]="+args[i]);
        }
    }
}

P385java代码块

-

package com.codeblock;
​
public class CodeBlock {
    public static void main(String[] args) {
        new Movie("小森");
        //输出电影打开广告开始电影正式开始Movie(String name)被调用
        //所以代码块的调用优先于构造器
    }
}
class Movie {
    private String name;
    private double price;
    private String director;
    //构造器-重载
    //下面三个构造器都有相同的语句，这个时候可以把三个语句放入先同的代码块中
    {//不管哪个构造器创建对象都会调用代码块
        System.out.println("电影打开");
        System.out.println("广告开始");
        System.out.println("电影正式开始");
    }
    public Movie(String name) {
        System.out.println("Movie(String name)被调用");
        this.name = name;
    }
    public Movie(String name, double price) {
        this.name = name;
        this.price = price;
    }
    public Movie(String name, double price, String director) {
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

-

package com.codeblock;
​
public class CodeBlock {
    public static void main(String[] args) {
        new Movie("小森");
        //输出电影打开广告开始电影正式开始Movie(String name)被调用
        //所以代码块的调用优先于构造器
    }
​
}
class Movie {
    private String name;
    private double price;
    private String director;
​
    //构造器-重载
    //下面三个构造器都有相同的语句，这个时候可以把三个语句放入先同的代码块中
    {//不管哪个构造器创建对象都会调用代码块
        System.out.println("电影打开");
        System.out.println("广告开始");
        System.out.println("电影正式开始");
    }
​
    public Movie(String name) {
        System.out.println("Movie(String name)被调用");
        this.name = name;
    }
​
    public Movie(String name, double price) {
        this.name = name;
        this.price = price;
    }
​
    public Movie(String name, double price, String director) {
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

P386代码块细节

2.类的加载演示

package com.codeblock;
​
public class CodeBlock {
    public static void main(String[] args) {
       //new AA();//1.创建实例对象调用，结果AA的静态代码块1被执行 AA默认构造器被调用
        //如果有两个代码块，会被一起调用，静态在之前。
       // new AA();//2.创建子类对象，父类也会加载
        //输出结果BB的静态代码块1被执行AA的静态代码块1被执行,代码块被调用,AA默认构造器被调用
        //System.out.println(Cat.n1); //3.使用类的静态成员时候（静态方法和属性）
        //输出结果Cat的静态代码1被执行//99
        //如果两个对象，静态代码库加载一次。stati代码块随着类的加载而执行一次，普通每次创建对象就执行
       // new DD();
       // new DD();
        //输出DD的静态代码块，DD的代码块，DD的代码块
        //3)普通代码块每次创建对象就执行，会被隐式调用，创建一次调用一次
        //如果是单纯调用类的静态成员，普通不会执行
        //System.out.println(DD.n1);//输出DD的静态代码块//11
        DD dd = new DD();//输出静态，代码，11
        System.out.println(dd.n1);
    }
}
class DD{
    public static int n1=11;
    static {
        System.out.println("DD的静态代码块");
    }
    {
        System.out.println("DD的代码块");
    }
}
class Cat{
    public static int n1=99;
    static {
        System.out.println("Cat的静态代码1被执行");
    }
    public  Cat(){
        System.out.println("Cat默认构造器");
    }
}
class BB {
    private String name;
    static {//不管哪个构造器创建对象都会调用代码块
        System.out.println("BB的静态代码块1被执行");
    }
}
class AA extends BB{
    private String name;
    //构造器-重载
    //下面三个构造器都有相同的语句，这个时候可以把三个语句放入先同的代码块中
    {
        System.out.println("代码块被调用");
    }
    static {//不管哪个构造器创建对象都会调用代码块
        System.out.println("AA的静态代码块1被执行");
    }
    public AA() {
        System.out.println("AA默认构造器被调用");
    }
}

-

package com.codeblock;
​
public class CodeBlockdetial {
    public static void main(String[] args) {
        //new A();//输出结果静态代码01被调用/getN1被调用，两者优先级相同，取决于写的代码的顺序
        //输出 普通代码库2被调用//getN2被调用//A默认构造器被调用
    }
}
class A{
    private static int n1=getN1();//静态对象初始化
    private int n2=getN2();
    static {
        System.out.println("静态代码01被调用");
    }
    {
        System.out.println("普通代码库2被调用");
    }
​
    public static int getN1(){
        System.out.println("getN1被调用");
        return 111;
    }
    public int getN2(){
        System.out.println("getN2被调用");
        return 222;
    }
    public A(){
        System.out.println("A默认构造器被调用");
    }
}

P387代码块的顺序

-

package com.codeblock;
​
public class CodeBlockdetial {
    public static void main(String[] args) {
        new B();//A静态代码01被调用
        //B静态代码01被调用
        //A普通代码库2被调用
        //A默认构造器被调用
        //普通代码库2被调用
        //B的无参构造器被调用
    }
}
class A{
​
    static {
        System.out.println("A静态代码01被调用");
    }
    {
        System.out.println("A普通代码库2被调用");
    }
​
    public A(){
        System.out.println("A默认构造器被调用");
    }
}
class B extends A{
    public B(){
        System.out.println("B的无参构造器被调用");
    }
    static {
        System.out.println("B静态代码01被调用");
    }
    {
        System.out.println("B普通代码库2被调用");
    }
}

-

P389代码块关于继承关系的顺序（面试）

(1)先进行类 的加载（先加载父类A，然后加载B）（静态成员，属性和方法看各自在代码的顺序）先执行完父类的静态成员，再执行子类的静态成员

(2)创建对象

执行子类的构造器（里面有父类的构造器{父类父类的构造器，普通代码块和普通属性}，普通代码块和普通属性），依次执行

package com.codeblock;
​
public class CodeBlockdetial {
    public static void main(String[] args) {
        new B();
​
    }
}
class A{
    private static int n1=getN1();//1.父类的加载
    private int n2=getN2();//5.普通属性的初始化（与6的优先级一样，但是代码顺序在前）
    public int getN2(){
        System.out.println("A的getN2的n2属性被调用");
        return 222;
    }
    public static int getN1(){
        System.out.println("静态方法的属性N1被调用");
        return 11;
​
    }
​
    static {//2.父类的加载
        System.out.println("A静态代码01被调用");
    }
    {//6.普通代码块
        System.out.println("A普通代码库2被调用");
    }
​
    public A(){//7.父类的构造器
        System.out.println("A默认构造器被调用");
    }
}
class B extends A{
    private static int nB1=getNB1();//3.子类的加载
    private int nB2=getNB2();//8.普通属性的初始化（与9的优先级一样，但是代码顺序在前）
    public int getNB2(){
        System.out.println("B的getN2的n2属性被调用");
        return 44;
    }
    public static int getNB1() {
        System.out.println("静态方法的属性NB1被调用");
        return 33;
    }
    public B(){//创建对象调用构造器从此开始
        //super()//父类的构造器
        //普通代码块和普通属性的初始化
        System.out.println("B的无参构造器被调用");//10.子类的构造器
    }
    static {//4.子类的加载
        System.out.println("B静态代码01被调用");
    }
    {//9.普通代码块
        System.out.println("B普通代码库2被调用");
    }
}
package com.codeblock;
​
public class CodeBlockdetial {
    public static void main(String[] args) {
        new C();//静态方法的属性N5被调用//C的getN4的n4属性被调用//C普通代码库2被调用//233
​
    }
}
class C{
    private static int n4=getN5();
​
    private int n2=getN4();//5.普通属性的初始化（与6的优先级一样，但是代码顺序在前）
    public int getN4(){
        System.out.println("C的getN4的n4属性被调用");
        return 222;
    }
    public static int getN5(){
        System.out.println("静态方法的属性N5被调用");
        return 11;
    }
    {
        System.out.println(" C普通代码库2被调用");
        System.out.println(n4+n2);
    }
}

P390练习

//类加载（静态成员）普通代码块+普通属性，

//静态成员sam初始化，static块执行，sam1成员初始化，test默认无参构造器