JAVA012--静态和多态

静态

public class Student {

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