一、多态
多态可以理解为事物存在的多种体现形态。
例:动物中猫,狗。猫这个对象对应的类型是猫类型,如:猫 x = new猫(); 同时猫也是动物中的一种,也可以把猫称为动物。动物 y = new猫(); 那么动物就是猫和狗具体事物中抽取出来的父类型。父类型引用指向了子类对象。
1、多态的体现:父类型的引用或者接口类型的引用指向子类类型的对象。
例如:Person p = new Student();
2、产生多态的前提:
a、类与类之间存在继承关系,类与接口之间存在实现关系。
b、通常会有覆盖操作。
3、多态的利与弊:
利:提高了程序的可扩展性和后期可维护性。
弊:只能使用父类中的引用访问父类中的成员。也就是说使用了多态,父类型的引用在使用功能时,不能直接调用子类中的特有方法。如:Animal a = new Cat(); 这就是多态的体现,假设子类Cat中有特有的抓老鼠功能,父类型的 a就不能直接调用。这上面的代码中,可以理解为Cat类型提升为Animal类型,向上转型。
如果此时父类的引用想要调用Cat中特有的方法,就需要强制将父类的引用,转成子类类型,向下转型。如:Cat c = (Cat)a;
注意:如果父类可以创建对象,如:Animal a = new Animal(); 此时,就不能向下转型了,Cat c = (Cat)a; 这样的代码就变得不容许,编译时会报错。所以千万不能出现这样的操作,就是将父类对象转成子类类型。
我们能转换的是父类引用指向了自己的子类对象时,该引用可以被提升,也可以被强制转换。多态至始至终都是子类对象在做着变化。
多态的代码示例:
abstract class Animal
{
public abstract void eat();
}
//子类————猫
class Cat extends Animal
{
//复写父类中的抽象功能
public void eat()
{
System.out.println("吃鱼");
}
//Cat特有的功能
public static void catchMouse()
{
System.out.println("抓老鼠");
}
}
class Demo
{
public static void main(String[] args)
{
Animal a = new Cat();
a.eat();
Cat c = (Cat)a;
c.catchMouse();
}
}
4、多态的特点
1)多态中非静态成员函数的特点:
在编译时期:参阅引用型变量所属的类中是否有调用的方法。如果有,编译通过,如果没有编译失败。
如:在上面的示例中,如果用a.catchMouse();编译就会报错。这时只能通过强转向下类型转换后,才可以使用子类的特有功能。
在运行时期:参阅对象所属的类中是否有调用的方法。这就是说,如果父类中有一个非抽象的方法,而子类继承后又将其复写了,在多态运行时,父类的引用调用这个同名函数时,被运行的将是父类中的方法。
简单总结就是:成员函数在多态调用时,编译看左边,运行看右边。
2)多态中成员变量的特点
无论编译和运行,都参考左边(引用变量所属的类)。如:多态中的父类引用调用成员变量时,如果父类和子类有同名的成员变量,那么被调用的是父类中的成员变量。
3)多态中静态成员函数的特点
无论编译和运行,都参考左边。也就是父类引用在调用静态同名函数时,被调用的是父类中的静态函数。这是因为,当类一被加载,静态函数就随类绑定在了内存中。此时,不需要创建对象,就可以使用类名直接调用。同时,父类中的静态成员函数一般是不被复写的。
5、多态的出现思想上也做着变化:以前是创建对象并指挥对象做事情。有了多态以后,我们可以找到对象的共性类型,直接操作共性类型即可,这样可以指挥一批对象做事情,即通过操作父类或接口实现。
二、内部类
1,概述:
如果A类需要直接访问B类中的成员,而B类又需要建立A类的对象。这时,为了方便设计和访问,直接将A类定义在B类中。A类就称为内部类。内部类可以直接访问外部类中的成员。而外部类想要访问内部类,必须要建立内部类的对象。
编译时,如果代码中有内部类,生成的class文件中会含有这样的文件:Test$1.class。编译器将会把内部类翻译成用$(美元符号)分隔外部类名和内部类名的常规类文件。这是内部类的一种编译现象。
2、内部类的访问规则:
1、内部类可以直接访问外部类中的成员,包括私有。
之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用,格式: 外部类名.this。
2、外部类要访问内部类,必须建立内部类对象。
3、访问格式:
当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他类中直接建立内部类对象。
格式:
外部类名.内部类名 变量名 =外部类对象.内部类对象;
如: Outer.Inner in =new Outer().new Inner();
当内部类在外部类中的成员位置上时,可以被成员修饰符所修饰。比如:
private:将内部类在外部类中进行封装。
static:内部类就局部static的特性。但是当内部类被static修饰后,只能直接访问外部类中的static成员。出现了访问局限。
在外部其他类中,直接访问static内部类的非静态成员的格式为:
new 外部类名.内部类名().方法名();
如:new Outer.Inner().function();
在外部其他类中,直接访问static内部类的静态成员格式为:
外部类名.内部类名.方法名();
如:Outer.Inner.function();
注意:
1)当内部类中定义了静态成员时,该内部类必须是static的。
2)当外部类中的静态方法访问内部类时,内部类也必须是static的。
3)在实际应用中,内部类通常被定义为private,而很少定义为public。
4,为什么内部类可以直接访问外部类中的成员呢?
那是因为内部中都持有一个外部类的引用。这个引用是 外部类名.this
内部类可以定义在外部类中的成员位置上,也可以定义在外部类中的局部位置上。
当内部类被定义在局部位置上,只能访问局部中被final修饰的局部变量。
三、匿名内部类:
1、概述:没有名字的内部类。就是内部类的简化形式。一般只用一次就可以用这种形式。匿名内部类其实就是一个匿名子类对象。想要定义匿名内部类:前提是内部类必须继承一个类或者实现接口。
2、匿名内部类的格式:new 父类名&接口名(){ 定义子类成员或者覆盖父类方法 }.方法。
3、匿名内部类的使用场景:
当函数的参数是接口类型引用时,如果接口中的方法不超过3个。可以通过匿名内部类来完成参数的传递。
其实就是在创建匿名内部类时,该类中的封装的方法不要过多,最好两个或者两个以内。
4,代码示例:
interface Inter
{
void method();
}
class InnerClassTest
{
public static void main(String[] args)
{
show(new Inter()
{//匿名内部类
public void method()
{
System.out.println("method show run");
}
});
}
public static void show(Inter in)
{
in.method();
}
}
5,匿名内部类的一个小练习:
interface Inter
{
void method();
}
class Test
{
//通过匿名内部类,补足代码。
}
class InnerClassDemo
{
public static void main(String[] args)
{
Test.function().method();
}
}
分析:
Test.function().method();//相当于Inter in=Test.function();
// in.method();
Test.function():Test类中有一个静态的方法function。
.method():说明调用function这个方法运算后的结果是一个对象。而且是一个Inter类型的对象,因为只有Inter类型的对象,才可以调用内部类中的method方法。
完整的代码如下:
interface Inter
{
void method();
}
class Test
{
static Inter function()
{
return new Inter()
{
public void method()
{
System.out.println("内部类练习");
}
};
}
}
class InnerClassDemo
{
public static void main(String[] args)
{
Test.function().method();
}
}