1.7Oob封装 继承 访问修饰符 静态和构造方法的执行顺序

1：访问修饰符

private     同类中

默认        同类        同包

protect    同类         同包      子类

public     同类        同包        子类         其它任何地方

2：导包

当两个类同名时  需要进行导包以区分，

3：继承

1）继承成员变量，但与访问修饰符有关系。

4：继承中的构造方法

1）子类中的构造方法默认调用父类的无参构造，如果用super在子类构造中调用父类的有参构造就会将父类的无参构造覆盖，如果在子类构造方法中用this调用

子类其它构造方法也会将父类默认无参构造进行覆盖；

2）子类的同一个构造方法中不可以同时存在super和this因为他们都需要放在方法里面的第一行。

5：子类调用父类的无参构造方法 super（），子类调用父类的有参构造方法super(参数);

6：静态方法，静态代码块，构造方法

1）执行顺序：

静态方法1      静态方法 2     静态方法3

静态代码块4   静态代码块6     静态代码块8

构造方法 5      构造方法7         构造方法9

2）如果创建两个对象对子类进行调用   静态代码块只执行一次，代码块和构造方法执行两次，静态方法的执行取决于是否被调用

public class A {
 
    static {
        System.out.println("static A");
    }
 
    {
        System.out.println("cdoe A ....");
    }
 
    public A() {
        System.out.println("con A");
    }
}
public class B  extends A{
 
    static {
        System.out.println("staticB");
    }
 
    {
        System.out.println("cdoeB ....");
    }
 
    public B() {
        super();
        System.out.println("con B");
    }
 
}
public class C  extends B{
 
    static {
        System.out.println("static C");
    }
 
    {
        System.out.println("cdoe C ....");
    }
 
    public C() {
        super();
        System.out.println("con C");
    }
}
 
public class Test {
 
    public static void main(String[] args) {
        C c = new C();
        //
        C c2 = new C();
 
    }
}

7：同类中成员方法和静态方法   访问成员变量，静态变量和静态方法 成员方法

public class B {
private int age;
 
    private static int love;
 
    public void show() {
        // 成员方法可以访问成员变量吗？ 1  访问静态变量吗？ 1
        age = 13;
        love = 14;
        noShow();
    }
 
    // 在静态方法当中不能访问实例变量（成员变量）， 必须确保当前已经产生了实例，再使用实例访问。
    public static void noShow() {
//            love = 55;
            //age=34;      报错
    }
}

8：静态实例2

public class StaticA {
 
    // static修饰 成员变量--》 变为类变量，静态变量
 
    public static int year = 2000;
 
    private static int love = -100;
 
    private int age;
 
    // 代码块，随着每个实例的创建都会执行一次
 
    static {
 
        System.out.println("静静地 睡觉！");
    }
 
    public StaticA() {
        System.out.println("我的构造器");
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public static void myLife() {
        System.out.println("流浪。。。。");
    }
 
}

public static void main(String[] args) {
        StaticA s = new StaticA();
        s.setAge(18);
 
        StaticA s2 = new StaticA();
        s2.setAge(19);
 
        System.out.println(s.getAge());
        System.out.println(s2.getAge());
 
        // 类变量的值（访问，类名.变量名访问），所有的对象也可以访问
        System.out.println(StaticA.year);
        System.out.println(s.year);
        System.out.println(s2.year);
        s.year  = 2001;
        System.out.println(StaticA.year);
        System.out.println(s.year);
        System.out.println(s2.year);
 
        // 使用静态方法 类名.方法名，   也可以使用对象.方法名
        // 提供是共性的功能。   编写工具类，工具方法
        StaticA.myLife();
        s.myLife();
    }
}

9：关于继承中静态代码块   代码块   无参构造  有参构造的执行情况

public class C {
    private int age;
 
    static {
        System.out.println("C静态代码块");
    }
    {
        System.out.println("C代码块");
    }
 
    public C() {
        super();
        System.out.println("C无参构造");
    }
 
    public C(int age) {
        super();
        this.age = age;
        System.out.println("C有参构造");
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
}

public class B extends C{
    private int name;
    static {
        System.out.println("B静态代码块");
    }
 
    {
        System.out.println("B代码块");
    }
 
    public B() {
        super();
        System.out.println("B无参构造");
    }
 
    public B(int name) {
        super();
        this.name = name;
        System.out.println("B有参构造");
 
    }
 
}

public class A extends B{
    private int tall;
    static {
        System.out.println("A静态代码块");
    }
    {
        System.out.println("A代码块");
    }
    public A() {
        super();
        System.out.println("A无参构造");
    }
    public A(int tall) {
        super();
        this.tall = tall;
        System.out.println("A有参构造");
    }
    public int getTall() {
        return tall;
    }
    public void setTall(int tall) {
        this.tall = tall;
    }
 
}

public class TextABC {
    public static void main(String[] args) {
        A a = new A();
        A b = new A(6);
    }
 
}
/*c静态代码块
b静态代码块
a静态代码块
c代码块
c无参
b代码块
b无参
a代码块
a无参
 
c代码块
c无参
b代码块
b无参
a代码块
ay有参
*/