java 自学日志【七】---面向对象之多态

------android培训，java培训，期待与您交流------

面向对象之多态

多态：事物存在的多种形式体现形态。

多态的基本体现：1.父类的引用指向了自己的子类对象；

                              2.父类的引用也可以接收自己子类的对象；

多态的前提：1. 类与类直接有关系，要么继承，要么实现；

                       2.存在覆盖；

多态的好处与弊端： 提高了程序的扩展性，但是只能使用父类的引用访问父类的成员；

子类对象被父类引用：子类对象在向上转型。
将指向子类对象的父类应用转换成子类类型引用：向下转型。

 

如果想调用子类特有方法，如何操作？

强制将父类的引用转成子类的引用。多态自始至终是子类对象在做着变化。

class 毕姥爷
{}

class 毕老师 extends 毕姥爷
{}

毕姥爷 ly = new 毕老师();//毕老师向上转型为了毕姥爷。向上转型

毕老师 ls = (毕老师)ly; //将代表毕老师对象的父类引用ly强制转换成了毕老师类型。向下转型。

在多态中，非静态成员函数的特点：

1. 在编译时，参阅引用型变量所属的类中是否有调用的方法，如果有，编译通过，如果没有，编译失败；

2.在运行时，参阅对象所属的类中是否有调用的方法；

简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

在多态中，非静态成员变量的特点：

无论编译还是运行，都参考左边，即引用型变量所属的类；

在多态中，静态成员函数的特点：

无论编译还是运行，都参考左边，即引用型变量所属的类；静态可以直接用类名调用，无需创建对象；

class Fu{static int num = 5;void method1(){System.out.println("fu method_1");}void method2(){System.out.println("fu method_2");}static void method4(){System.out.println("fu method_4");}}class Zi extends Fu{static int num = 8;void method1(){System.out.println("zi method_1");}void method3(){System.out.println("zi method_3");}static void method4(){System.out.println("zi method_4");}}class  DuoTaiDemo4{public static void main(String[] args) {//Fu f = new Zi();////System.out.println(f.num);////Zi z = new Zi();//System.out.println(z.num);//f.method1();//f.method2();//f.method3();Fu f = new Zi();System.out.println(f.num);f.method4();Zi z = new Zi();z.method4();//Zi z = new Zi();//z.method1();//z.method2();//z.method3();}}

 

 

Object是所有对象的直接或间接的父类，该类中定义的是所有对象都具备的功能；

equals：比较两个对象是否“相等”；

toString：返回该对象的字符串表示；

hashCode:返回该对象的哈希值；

内部类：将一个类定义在另一个类的里面，对里面那个类就称为内部类，或内置类，嵌套类。

内部类访问规则：1.内部类可以直接访问外部类中的成员，包括私有；之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类中的引用，格式：外部类名.this；2.外部类要访问内部类，必须建立内部类对象；

private私有，可以修饰成员变量和方法，但不能在方法体内；不可以修饰局部变量和类，修饰类只能修饰内部类；

class Outer{private int x = 3;class Inner//内部类{//int x = 4;void function(){//int x = 6;System.out.println("innner :"+Outer.this.x);}}/**/void method(){Inner in = new Inner();in.function();}}class  InnerClassDemo{public static void main(String[] args) {Outer out = new Outer();out.method();//直接访问内部类中的成员。//Outer.Inner in = new Outer().new Inner();//in.function();}}

内部类访问格式：

① 当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中直接建立内部类对象：

格式： 外部类名.内部类名  变量名 = 外部类对象.内部类对象;

Outer.Inner  in = new Outer(). new Inner();

②当内部类在成员位置上时，就可以被成员修饰符所修饰；

比如：private，讲内部类在外部类中进行封装；

           static，内部类就具备了静态特性，被修饰后，内部类只能访问外部类中的静态成员；

在外部其他类中，如何直接访问静态内部类的非静态成员？new Outer.Inner().function();创建对象调用。

在外部其他类中，如果直接访问静态内部类的静态成员？Outer.Inner().function(); 直接调用。

注意：当内部类中定义了静态成员，该内部类必须是静态；

            当外部类中的静态方法访问内部类时，内部类必须是静态；

class Outer{private static  int x = 3;static class Inner//静态内部类{static void function(){System.out.println("innner :"+x);}}static class Inner2{void show(){System.out.println("inner2 show");}}public static void method(){//Inner.function();new Inner2().show();}}class  InnerClassDemo2{public static void main(String[] args) {Outer.method();//Outer.Inner.function();//new Outer.Inner().function();//直接访问内部类中的成员。//Outer.Inner in = new Outer().new Inner();//in.function();}}

③当内部类定义在局部时，不可以被成员修饰符修饰，可以直接访问外部类中的成员，因为还有外部类中的引用，但是，不可以访问局部它所在局部中的变量，只能访问被final修饰的局部变量。

class Outer{int x = 3;void method(final int a){final int y = 4;class Inner{void function(){System.out.println(y);}}new Inner().function();}}class  InnerClassDemo3{public static void main(String[] args) {Outer out = new Outer();out.method(7);out.method(8);}}

匿名内部类：内部类的简写格式；

定义匿名内部类的前提，内部类必须是继承一个类或实现了一个接口；

格式：new 父类或接口（）{子类定义的内容}

其实匿名内部类就是一个子类对象，可以理解为带内容的对象，匿名内部类最好不要超过3个。

内部类可以直接继承其他外部类。

abstract class AbsDemo{abstract void show();}class Outer{int x = 3;public void function(){AbsDemo d = new AbsDemo(){int num = 9;void show(){System.out.println("num==="+num);}void abc(){System.out.println("haha");}};d.show();d.abc();//编译失败;父类中没有定义过。}}