------- android培训、 java培训、期待与您交流! ----------
4.9 多态
多态:可以理解为事物存在的多种体现形态。
人:男人,女人
动物:猫,狗。
猫 x = new 猫();
动物 x = new 猫();
-------------------------------------------------
(1)多态的体现
父类的引用指向了自己的子类对象。
父类的引用也可以接收自己的子类对象。
实例:
//父类动物
abstract class Animal
{
abstract void eat();
}
//子类猫
class Cat extends Animal
{
public void eat()
{
System.out.println("吃鱼");
}
public void catchMouse()
{
System.out.println("抓老鼠");
}
}
//子类狗
class Dog extends Animal
{
public void eat()
{
System.out.println("吃骨头");
}
public void kanJia()
{
System.out.println("看家");
}
}
//子类猪
class Pig extends Animal
{
public void eat()
{
System.out.println("饲料");
}
public void gongDi()
{
System.out.println("拱地");
}
}
class DuoTaiDemo
{
public static void main(String[] args)
{
function(new Cat());
function(new Dog());
function(new Pig());
}
public static void function(Animal a)//Animal a = new Cat();
{
a.eat();
}
-------------------------------------------------
(2)多态的前提
必须是类与类之间有关系。要么继承,要么实现。
通常还有一个前提:存在覆盖。
-------------------------------------------------
(3)多态的好处
多态的出现大大的提高程序的扩展性(一年之后写出来的东西,让进去一样可以用)。
-------------------------------------------------
(4)多态的弊端
提高了扩展性,但是只能使用父类的引用访问父类中的成员。
-------------------------------------------------
(5)多态的应用
Animal a = new Cat();//类型提升。 向上转型。
a.eat();
如果想要调用猫的特有方法时,如何操作?
强制将父类的引用。转成子类类型。向下转型。
Cat c = (Cat)a;
c.catchMouse();
错误情况:
Animal a = new Animal();
Cat c = (Cat)a;
注意:千万不要出现这样的操作,就是将父类对象转成子类类型。
因为父类中没有子类中特有的方法。
总结:我们能转换的是父类应用指向了自己的子类对象时,该应用可以被提升,也可以被强制转换。
多态自始至终都是子类对象在做着变化。
-------------------------------------------------
举例:
//毕姥爷、毕老师都具有讲课的功能,毕老师继承毕姥爷的讲课功能,覆写了教课功能(教java)
毕姥爷 x = new 毕老师();//毕老师化妆成毕姥爷去讲课
x.讲课();//毕老师讲课java
毕老师 y = (毕老师)x;//毕老师显身,就可以使用毕老师特有的功能了
-------------------------------------------------
instanceof : 用于判断对象的类型。对象 intanceof 类型(类类型 接口类型)
实例:
public static void function(Animal a)//Animal a = new Cat();
{
a.eat();//共有功能
/*错误,因为父类写上面,下面的判断就得不到了
if(a instanceof Animal)
{
System.out.println("haha");
}*/
//判断是哪个子类型,调用起特有功能
else if(a instanceof Cat)
{
Cat c = (Cat)a;
c.catchMouse();
}
else if(a instanceof Dog)
{
Dog c = (Dog)a;
c.kanJia();
}
-------------------------------------------------
(6)多态的出现代码中的特点(多态使用的注意事项)
实例:
Fu f = new Zi();
f.method1();
f.method2();
f.method3();
编译时期:看左边父类f,有method1()、method2()但是,没有method3()。所以编译失败。
运行时期:看右边子类new Zi()。
总结:在多态中成员函数的特点:
在编译时期:参阅引用型变量所属的类中是否有调用的方法。如果有,编译通过,如果没有编译失败。
在运行时期:参阅对象所属的类中是否有调用的方法。
简单总结就是:成员函数在多态调用时,编译看左边,运行看右边。
(面试专用)实例:
Fu f = new Zi();
System.out.println(f.num);//父类num
Zi z = new Zi();
System.out.println(z.num);//子类num
在多态中,成员变量的特点:
无论编译和运行,都参考左边(引用型变量所属的类)。
(面试专用)实例:
class Fu
{
void method1()
{
System.out.println("fu method_1");
}
static void method4()
{
System.out.println("fu method_4");
}
}
class Zi extends Fu
{
void method1()
{
System.out.println("zi method_1");
}
static void method4()
{
System.out.println("zi method_4");
}
}
Fu f = new Zi();
f.method4();//结果是父类的
Zi f = new Zi();
f.method4();//结果是子类的
记住:
在多态中,静态成员函数的特点:
无论编译和运行,都参考做左边。
原因:static方法先加载进内存,不需要对象。只有是父类所属引用,找的就是父类中的方法。
-------------------------------------------------
动态绑定和静态绑定
方法区有静态区和非静态区,method1在非静态区,里面有this,super。method4()一进内存,由于是静态方法,就已经被绑定了,绑定在这个方法所属类上。比如Fu.method4()就是绑定在父类静态绑定。
this.method1()动态绑定,this指向哪个对象就是那个对象,f.method1()可以,因为f相当于new Zi(),所以运行的还是子类方法。
-------------------------------------------------
多态电脑运行实例:
/*
需求:
电脑运行实例,
电脑运行基于主板。
思路:
1.统一的接口
2.接口型引用指向自己的子类对象。
*/
interface PCI
{
public void open();
public void close();
}
class MainBoard
{
public void run()
{
System.out.println("mainboard run ");
}
public void usePCI(PCI p)//PCI p = new NetCard()//接口型引用指向自己的子类对象。
{
if(p!=null)
{
p.open();
p.close();
}
}
}
class NetCard implements PCI
{
public void open()
{
System.out.println("netcard open");
}
public void close()
{
System.out.println("netcard close");
method();
}
}
class SoundCard implements PCI
{
public void open()
{
System.out.println("SoundCard open");
}
public void close()
{
System.out.println("SoundCard close");
}
}
class DuoTaiDemo5
{
public static void main(String[] args)
{
MainBoard mb = new MainBoard();
mb.usePCI(new NetCard());
mb.usePCI(new SoundCard());
}
}
//结论:多态,接口降低了程序耦合性,提高了功能扩展性,提供了规则。
-------------------------------------------------
多态拓展实例,数据库操作。
/*
需求:数据库的操作。
数据是:用户信息。
1,连接数据库。JDBC Hibernate
2,操作数据库。
c create r read u update d delete
3,关闭数据库连接。
*/
interface UserInfoDao
{
public void add(User user);
public void delete(User user);
}
class UserInfoByJDBC implements UserInofDao
{
public void add(User user)
{
1,JDBC连接数据库。;
2,使用sql添加语句添加数据。;
3,关闭连接。
}
public void delete(User user)
{
1,JDBC连接数据库。;
2,使用sql添加语句删除数据。;
3,关闭连接。
}
}
class UserInfoByHibernate implements UserInfoDao
{
public void add(User user)
{
1,Hibernate连接数据库。;
2,使用sql添加语句添加数据。;
3,关闭连接。
}
public void delete(User user)
{
1,Hibernate连接数据库。;
2,使用sql添加语句删除数据。;
3,关闭连接。
}
}
class DBOperate
{
public static void main(String[] args)
{
UserInfoDao ui = new UserInfoByHibernate();
ui.add(user);
ui.delete(user);
}
}
无论怎么连接数据库,都在增删改查,但是,内部代码不一样。先定义规则,统一的接口,降低耦合性。前期UserInfoDao ui= 统一规则有了。后来,UserInfoDao ui= new UserInfoByJDBC()。再后来出现了,UserInfoByHibernate,可以这样UserInfoDao ui= new UserInfoByHibernate()。
还有一个办法,不用进行修改,那就是反射。直接去访问这个文件名对象的文件,手动加载进内存去创建对象。
-------------------------------------------------
特殊的东西:object
是所有对象的直接后者间接父类,传说中的上帝。
该类中定义的肯定是所有对象都具备的功能。
java认为所有对象都具有对象是否相同的比较方法equals()
如果自定义类中也有比较相同的功能,没有必要重新定义。
只要沿袭父类中的功能,建立自己特有比较内容即可。这就是覆盖。
实例:
class Demo //extends Object
{
}
class ObjectDemo
{
public static void main(String[] args)
{
Demo d1 = new Demo();
Demo d2 = new Demo();
Demo d3 = d1;
d1.equals(d3);//true
d1==d2;//false
d1==d3;//true
}
}
结论:equals是相当于 == 比较地址
-------------------------------------------------
有特殊需要的时候,覆写equals
class Demo //extends Object
{
private int num;
Demo(int num)
{
this.num = num;
}
public boolean equals(Object obj)//Object obj = new Demo();
{
if(!(obj instanceof Demo))
return false;
Demo d = (Demo)obj;
return this.num == d.num;
}
-------------------------------------------------
object中的 toString()
所有类都可以变成字符串被打印
Demo d1 = new Demo(4);
System.out.println(d1);
//输出语句打印对象时,会自动调用对象的toString方法。打印对象的字符串表现形式。
-------------------------------------------------
部分反射的知识:
Demo d1 = new Demo();
Class c = d1.getClass();
System.out.println(c.getName());//得到d1的类名demo
-------------------------------------------------
System.out.println(c.getName()+"@@"+Integer.toHexString(d1.hashCode()));
相当于:toString()
-------------------------------------------------
因为特殊需要,覆写toString()
实例:
class Demo //extends Object
{
private int num;
Demo(int num)
{
this.num = num;
}
public String toString()
{
return "demo:"+num;
}
}
-------------------------------------------------
小知识点:内部类(用于面试)
什么是内部类?
将一个类定义在另一个类的里面,对里面那个类就称为内部类(内置类,嵌套类)。
内部类有什么好处?
内部类可以无限制访问外部类成员
内部类的访问规则:
1,内部类可以直接访问外部类中的成员,包括私有。
之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用,格式 外部类名.this
2,外部类要访问内部类,必须建立内部类对象。
怎么访问内部类?
Outer.Inner in = new Outer().new Inner();//直接访问内部类中的成员。
访问格式:
1,当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他类中。
可以直接建立内部类对象。
格式
外部类名.内部类名 变量名 = 外部类对象.内部类对象;
Outer.Inner in = new Outer().new Inner();
2,当内部类在成员位置上,就可以被成员修饰符所修饰。
比如,private:将内部类在外部类中进行封装。
特点:内部类可以作为外部类的成员 被 private修饰。
-------------------------------------------------
实例:
class Outer
{
private int x = 3;
class Inner//内部类
{
int x = 4;
void function()
{
int x = 6;
System.out.println("innner :"+Outer.this.x);
}
}
}
如果是局部有x,就直接访问x; this.x 访问内部类的成员变量x;Outer.this.x 访问外部类的成员变量x。如果方法中,内部类中都没有x,x就可以访问外部类的成员变量x,相当于省略了Outer.this。
-------------------------------------------------
静态内部类的问题:
static:内部类就具备static的特性。
当内部类被static修饰后,只能直接访问外部类中的static成员。出现了访问局限。
在外部其他类中,如何直接访问static内部类的非静态成员呢?
new Outer.Inner().function();
在外部其他类中,如何直接访问static内部类的静态成员呢?
Outer.Inner.function();
注意:当内部类中定义了静态成员,该内部类必须是static的。
当外部类中的静态方法访问内部类时,内部类也必须是static的。
-------------------------------------------------
内部类可以写在类的任意位置。
内部类定义在局部时,
1,不可以被成员修饰符修饰
2,可以直接访问外部类中的成员,因为还持有外部类中的引用。
但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
注意:只有定义在成员位置上时,才能被static和private修饰。一般内部类不会被公有修饰。
实例:
class Outer
{
int x = 3;
void method(final int a)
{
final int y = 4;
class Inner
{
void function()
{
System.out.println(y);//只能访问被final修饰的局部变量
}
}
new Inner().function();//必须放在后面,类要读到了,才能加载进来
}
}
注意:
Outer out = new Outer();
out.method(7);//final int a
out.method(8);
是可以使用的。
为什么?
因为method()进入堆内存,运行完之后,被清除了。再调用就是新的final int a。
-------------------------------------------------
小知识点:匿名内部类
1,匿名内部类其实就是内部类的简写格式。
2,定义匿名内部类的前提:
内部类必须是继承一个类或者实现接口。
3,匿名内部类的格式: new 父类或者接口(){定义子类的内容}
4,其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。 可以理解为带内容的对象。
5,匿名内部类中定义的方法最好不要超过3个。
简写都有其好处和弊端。
实例:
abstract class AbsDemo
{
abstract void show();
}
class Outer
{
public void function()
{
//匿名内部类
new AbsDemo()
{
void show()
{
System.out.println("num==="+num);
}
}.show();//相当于new Inner().show();
}
}
为什么这么做?
因为要把AbsDemo中的抽象方法覆盖掉。总体是AbsDemo的子类对象,因为只有子类才能实现抽象类。
-------------------------------------------------
注意:匿名内部类只能使用父类的方法,不能使用子类特有的方法。关键:我们写匿名内部类就是为了覆盖方法,简化书写,所以,不应该再为子类添加特有方法。
-------------------------------------------------
局限:
1.不能直接调用自己特有的方法,只能调用父类的方法。
2.不能进行强制转换。
3.父类方法过多,不能使用匿名内部类,因为阅读性非常差。不超多三个。
-------------------------------------------------
小练习:
interface Inter
{
void method();
}
class Test
{
//补足代码。通过匿名内部类。
}
class InnerClassTest
{
public static void main(String[] args)
{
Test.function().method();
}
}
1.Test.function():Test类中有一个静态的方法function。
2..method():function这个方法运算后的结果是一个对象。而且是一个Inter类型的对象。因为只有是Inter类型的对象,才可以调用method方法。
3.static Inter function(){return new Inter()
{public void method()
{
System.out.println("method run");
}
}; }