多态
------- android培训、java培训、期待与您交流! ----------
人:男,女
动物:猫,狗
猫 x=new 猫();
动物 x=new 猫();
1,多态的体现
父类的引用指向了自己的子类对象 如:Animal c=new Cat();Animal d=new Dog();
父类的引用也可以接受自己的本类对象,提高了代码的扩展系性
2,多态的前提
必须有雷雨类之间有继承,要么实现
通常还有一个前提,就是覆盖
3,多态的好处
多态的出现大大的提高了程序的扩展性
4,多态的弊端
提高了扩展型,但是只能引用父类中的成员
*/
在多态中成员函数的特点:
在编译时期:参与引用型变量所属的类中是否有调用的方法,如果有,编译通过,如果没有编译失败。
在运行时期:参阅对象所属的;类中是否有调用的方法
简单总结:成员函数在多态调用时,编译看左边,运行看右边
在多态中静态成员函数的特点,无论编译运行都惨考左边
在多态中成员变量的特点:
无论编译和运行,都参考左边(引用型变量所属的类)
/*
需求:
电脑运行实例,
电脑运行基于主板。
*/
/*
v1.0 毫无扩展性
class MainBoard
{
publicvoid run()
{
System.out.println("mainBordrun");
}
}
class DuoTaiDemo5
{
publicstatic void main(String[] args)
{
MainBoardmb=new MainBoard();
mb.run();
}
}
*/
/*
v2.0 耦合性太强不利于扩展
class MainBoard
{
publicvoid run()
{
System.out.println("mainBordrun");
}
publicvoid useNetCard(NetCard c)
{
c.open();
c.close();
}
}
class NetCard
{
publicvoid open()
{
System.out.println("netcardopen");
}
publicvoid close()
{
System.out.println("netcardclose");
}
}
class DuoTaiDemo5
{
publicstatic void main(String[] args)
{
MainBoardmb=new MainBoard();
mb.run();
mb.useNetCard(newNetCard());
}
}
*/
/*
v3.0 mainbord-->PCI-->netcard soundcard 实例化
*/
interface PCI
{
publicvoid open();
publicvoid close();
}
class NetCard implements PCI
{
publicvoid open()
{
System.out.println("netcardopen");
}
publicvoid close()
{
System.out.println("netcardclose");
}
}
class SoundCard implements PCI
{
publicvoid open()
{
System.out.println("soundcardopen");
}
publicvoid close()
{
System.out.println("soundcardclose");
}
}
class MainBoard
{
publicvoid run()
{
System.out.println("mainBordrun");
}
publicvoid usePCI(PCI p)//接口不是不能实例化吗?接口性指向自己的子类对象
{
if(p!=null)
{
p.open();
p.close();
}
}
}
class DuoTaiDemo5
{
publicstatic void main(String[] args)
{
MainBoardmb=new MainBoard();
mb.run();
mb.usePCI(newNetCard());
mb.usePCI(newSoundCard());
}
}
/*
需求:数据库的操作
数据是:用户信息
1,连接数据库 JDBC Hibernate
2,操作数据库
增,删,改,查()
createread update delete
3,关闭数据库连接
*/
interface UserInfoDao
{
publicvoid add(User user);
publicvoid delete(User user);
}
class UserInfoByJDBC implements UseInfoDao
{
publicvoid add(User user)
{
1,JDBC连接数据库
2,使用sql语句添加数据
3,关闭连接
}
publicvoid delete(User user)
{
1,JDBC连接数据库
2,使用sql语句删除数据
3,关闭连接
}
}
class UseInfoByHiBernate implements UseInfoDao
{
publicvoid add(User user)
{
1,HiBernate连接数据库
2,使用sql语句添加数据
3,关闭连接
}
publicvoid delete(User user)
{
1,HiBernate连接数据库
2,使用sql语句删除数据
3,关闭连接
}
}
class JDBOperate
{
publicstatic void main(String[] args)
{
//UsrInfoByJDBCui=new UsrInfoByJDBC();
UserInfoDaoui=new UsrInfoByJDBC();
UserInfoDaoui=new UsrInfoByHiberate();
ui.add(user);
ui.delete(user);
}
}
Object类
内部类
/*
内部类的访问规则:
1,内部类可以直接访问外部类的成员,包括私有,是因为内部类中持有了一个外部类的引用。格式:外部类名.this.XXX
2,外部类要访问内部类,必须建立内部对象
访问格式:
1,当内部类定义在外部类成员位置上,而且非私有,可以在外部其他类中。
可以直接建立内部类对象。
格式:
外部类名.内部类名 变量名=外部类对象.内部类对象
Outer.Innerin=new Outer().new Inner();
2,当内部类在成员位置上,就可以被成员修饰符所修饰
比如:private:将内部类在外部类中进行封装
static:内部类就具备了静态的特性
当内部类被静态修饰后,只能直接访问外部类中static成员。出现了访问的局限
在外部其他类中,如何直接访问static内部类呢?
newOuter.Inner().function();
注意:党内部类中定义了静态成员,该内部类必须是static的
当外部类中静态方法访问内部类时,内部类也必须是static的
3,当描述事物时,事物内部还有事物,该事物用内部类来描述。
因为内部事务在使用外部事物的内容
/描述人体/
class Body
{
class Xinzang
{
}
}
*/
class Outer
{
intx=3;
privateint y=4;
//内部类
classInner
{
inty=9;
voidfunction()
{
inty=6;
System.out.println("Inner:"+x);
}
}
voidmethod()
{
Innerin=new Inner();
in.function();
}
}
class InnerClassDemo
{
publicstatic void main(String[] args)
{
Outerout=new Outer();
out.method();
}
}
/*
匿名内部类:
1,匿名内部类其实就是内部类的简写格式
2,定义匿名内部类的前提:
内部类必须是继承一个类或者实现接口
3,匿名内部类的格式:new 父类或者接口(){定义子类的内容}
4,其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖可以理解为带内容的对象
5,匿名内部类中定义的方法最好不要超过3个。
*/
abstract class AbsDemo
{
abstractvoid show();
}
class Outer
{
intx=3;
/*classInner extends AbsDemo
{
voidshow()
{
System.out.println("method:"+x);
}
}
*/
publicvoid function()
{
//newInner().show();
newAbsDemo()//匿名内部类举例
{
voidshow()
{
System.out.println("method:"+x);
}
}.show();
}
}
class InnerClassDemo3
{
publicstatic void main(String[] args)
{
newOuter().function();
}
}
interface Inter
{
voidmethod();
}
class Test
{
//补足代码。通过匿名内部类
/*staticclass Inner implements Inter
{
publicvoid method()
{
System.out.println("methodrun");
}
}*/
staticInter function()
{
returnnew Inter()
{
publicvoid method()
{
System.out.println("methodrun");
}
};
}
}
class InnerClassTest
{
publicstatic void main(String[] args)
{
//Test.function();//Test类中有一个静态方法function
//.method(); function这个方法运算后结果是一个对象,而且还是一个Inter类型的变量
//因为只有是Inter类型的对象,才可以调用method方法
Test.function().method();
/*
Interin=Test.function();
in.method();
*/
show(newInter()
{
publicvoid method()
{
System.out.println("methodshow run");
}
});//这里一定要小心
}
publicstatic void show(Inter in)
{
in.method();
}
}
/*
下面是一个面试题
*/
class InnerTest
{
publicstatic void main(String[] args)
{
newObject()
{
publicvoid function()
{
}
}.function();
}
}