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

佚名 6年前 (2019-04-08) 随笔 1554人围观抢沙发百度已收录

1：访问修饰符

private 同类中

SRE实战互联网时代守护先锋，助力企业售后服务体系运筹帷幄！一键直达领取阿里云限量特价优惠。

默认同类同包

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有参
*/