JAVA012--静态和多态

静态

public class Student {

// static修饰的属性--静态属性或者类属性
// 该属性没有存放在对象身上，而是单独存放在数据段的静态区
// 全类共享1个--对象.name或者类名.name
// 它与对象无关，与类有关
// 该属性是在加载期即被产生，初始化
// 常量属性可以直接写成public static final的
// 变量属性要分析出一定符合全类共享一个值，才能设计为static
public static String name1 = "li4";
public String name = "zhang3";

// static修饰的方法--静态方法或者类方法
// 该方法与对象无关，与类有关
// 静态方法里面不能写this，因为有可能是使用类名调用，此时没有当前对象
// 静态方法里面只能调用到静态属性，不能调用非静态属性
// 静态方法只能调用静态方法，不能调用非静态方法
// 非静态方法既可以调用静态方法，也可以调用非静态方法
// 其原因是static方法在加载期优先被加载
// 只有在遇到工具类的工具方法时，我们才将这类方法设计为static的
public static void test() {
    System.out.println("调用到了test方法，name属性的值是：" + name1);
    test1();
}

public static void test1() {

}

public void test2() {
    test1();
}

内部类

//外部类
public class OutClass {

public int fieldA;

// 成员内部类
// Class文件名---外部类类名$内部类类名.class
// 可以有访问修饰符，控制能否在本类之外被使用(属性也是如此)
// 可以有属性、初始化块、构造、方法，但都不能是static的---因为该内部类与外部类对象相关！
public class InnerClassA {
    private int a;

    private int fieldA;

    {
        System.out.println("InnerClassA的实例初始化块");
    }

    public InnerClassA() {
        System.out.println("InnerClassA的构造");
    }

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    //成员内部类的方法可以操作外部类的属性和方法(不管是否是static的)
    public void aa() {
        test();
        //当内部类与外部类有同名属性的时候，this.属性指代的是内部类的，外部类.this.属性才能指代外部类的该属性。
        System.out.println("InnerClassA的aa方法" + OutClass.this.fieldA);
    }
}


//静态内部类---成员内部类的特例
//Class文件名---外部类类名$内部类类名.class
//可以有访问修饰符，控制能否在本类之外被使用(属性也是如此)
//可以有属性、初始化块、构造、方法，除了构造都可以是static的---因为该内部类与外部类对象无关！
public static class InnerClassC{
    public static int c;

    static{
        System.out.println("InnerClassC的实例初始化块");
    }

    public InnerClassC(){
        System.out.println("InnerClassC的构造");
    }

    //静态内部类的方法（无论是否是static的），只能操作外部类的static属性和static方法
    public void cc(){
        test2();
        System.out.println("InnerClassC的cc方法");
    }
}

public void test() {
    int a = 100;
    // 局部内部类
    // Class文件名---外部类类名$序号内部类类名.class
    // 没有访问修饰符，只能在本方法中被使用(局部变量也是如此)
    // 可以有属性、初始化块、构造、方法，但都不能是static的---因为局部内部类不仅与对象无关、与类也不管、只跟方法的调用有关
    class InnerClassB {
        private int b;

        {
            System.out.println("InnerClassB的实例初始化块");
        }

        public InnerClassB(){
            System.out.println("InnerClassB的构造");
        }

        //局部内部类的方法中，可以操作外部类的属性和方法(不管是否是static)
        //但是不能调用到所在外部类方法的局部变量，但外部类方法的常量可以调用到
        public void bb(){
            test2();
            System.out.println("InnerClassB的bb方法" + fieldA);
        }
    }

    InnerClassB icb = new InnerClassB();
    icb.bb();
}

public static void test2(){
    final int t = 10;
    System.out.println("外部内的test2方法");

    //匿名内部类---在new对象的时候，才去定义该类有哪些属性和方法。
    //Class文件名---外部类类名$序号.class
    //没有访问修饰符，只能在本方法中使用1次
    // 可以有属性、初始化块、构造、方法，但都不能是static的---因为局部内部类不仅与对象无关、与类也不管、只跟方法的调用有关
    new Object(){
        private int d;

        //局部内部类的方法中，可以操作外部类的属性和方法(不管是否是static)
        //但是不能调用到所在外部类方法的局部变量，但外部类方法的常量可以调用到
        public void dd(){
            System.out.println("匿名内部类的DD方法" + t);
            this.hello();
        }

        private void hello(){
            System.out.println("Hello World!");
        }
    }.dd();
}

//成员内部类使用：首先产生外部类对象，然后用外部类对象.new的方式产生内部类对象
OutClass out = new OutClass();
OutClass.InnerClassA ica = out.new InnerClassA();

    //静态内部类使用：
    OutClass.InnerClassC icc = new OutClass.InnerClassC();

多态

public static void main(String[] args) {
// TODO Auto-generated method stub
//静态多态：在编译期就能确定执行的方法
//体现一：方法的重载
// Human zhang = new Human();
// zhang.eat();
// zhang.eat(“火锅”);
//体现二：单独使用方法的重写
// ITTeacher li = new ITTeacher();
// li.teach();
// EnglishTeacher liu = new EnglishTeacher();
// liu.teach();

    //向上转型技术--自动转换，绝对成功，没有风险
    //当父类的引用指向子类的对象时，该引用只能看到来自父类的属性行为，看不到子类特有的属性行为
    //当父类的引用指向子类的对象时，该引用调用被子类重写的方法，得到的是子类重写后的效果

// Teacher wang = new ITTeacher();
// wang.teach();

    //向下转型技术---强制转换，不一定成功，有风险
    //只有在本类的引用指向本类的对象才能成功

// ITTeacher li = (ITTeacher)new Teacher();
// EnglishTeacher liu = (EnglishTeacher)wang;

    //动态绑定--父类的引用指向子类对象，同时调用父类被重写方法
    Boy wxb = new Boy();
    PureGirl shuanger = new PureGirl();
    BoldGirl jianning = new BoldGirl();
    wxb.setMyGirl(shuanger);
    wxb.kiss();

}