---------------------- ASP.Net+Android+IO开发S、.Net培训、期待与您交流! ----------------------
概述
多态的概念:可以理解为事物存在的多种体现形态。
1、 多态的体现:
父类的引用指向了自己的子类对象
父类的引用也可以接受子类对象。
2、 多态的前提
必须是类与类之间有关系,要么继承,要么实现
3、 多态的好处
大大提高了程序的扩展性
4、 多态的弊端
5、多态的应用提高了扩展性,但是只能使用父类的引用访问父类中的成员。
示例代码如下:
class Student{ public abstract void study(); public void sleep(){ System.out.println("躺着睡"); } } class DoStudent{ public void dosome(Student stu){ stu.study(); stu.sleep(); } } class BaseStudent extends Student{ public void study(){ System.out.println("base study"); } public void sleep(){ System.out.println("坐着睡"); } } class AdvStudent extends Student{ public void study(){ System.out.println("adv study"); } } public class Demo{ public static void main(String[] args){ BaseStudent bs=new BaseStudent(); bs.study(); bs.sleep(); AdvStudent bs=new AdvStudent(); as.study(); as.sleep(); DoStudent ds=new DoStudent(); ds.dosome(new BaseStudent()); ds.dosome(new BaseStudent()); } }
成员的特点
1、成员变量
编译时:参考引用型变量所属的类中的是否有调用的成员变量,有,编译通过,没有,编译失败。
运行时:参考引用型变量所属的类中的是否有调用的成员变量,并运行该所属类中的成员变量。
简单总结:编译和运行都参考等号的左边。
2、成员函数(非静态)
编译时:参考引用型变量所属的类中的是否有调用的函数。有,编译通过,没有,编译失败。
运行时:参考的是对象所属的类中是否有调用的函数。
简单总结:编译看左边,运行看右边。因为成员函数存在覆盖特性。
3、静态函数
编译时:参考引用型变量所属的类中的是否有调用的静态方法。
运行时:参考引用型变量所属的类中的是否有调用的静态方法。
其实对于静态方法,是不需要对象的。直接用类名调用即可。
简单总结:编译和运行都看左边。
4、总结
非静态成员函数,编译时看左边,运行时看右边。其他都看左边。
多态的主板示例
interface PCI{ public abstract void open(); public abstract void close(); } class MainBoard{ public void run(){ System.out.println("mainboard run"); } public void usePCI(PCI p){ 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"); } } class SoundCard implements PCI{ public void open(){ System.out.println("soundcard open"); } public void close(){ System.out.println("soundcard close"); } } public class Demo{ public static void main(String[] args){ MainBoard mb=new MainBoard(); mb.run(); mb.usePCI(null); mb.usePCI(new NetCard()); mb.usePCI(new SoundCard()); } }
多态的扩展示例
interface UserInfoDao{ public void add(User user); public void delete(User user); } class UserInfoByJDBC implements UserInfoDao{ public void add(User user){ 1、JDBC连接数据库 2、使用sql添加语句添加数据 3、关闭连接 } public void delete(User user){ 1、JDBC连接数据库 2、使用sql添加语句删除数据 3、关闭连接 } } class DBOperate{ public static void main(String[] args){ UserInfoDao ui=new UserInfoByJDBC(); ui.add(user); ui.delete(user); } }
Object类中方法示例
class Demo{ //extends Object private int num; Demo(){} 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==obj.num; } public String toString(){ return "demo:"+num; } } public class ObjectDemo{ public static void main(String[] args){ Demo d1=new Demo(); Demo d2=new Demo(); Demo d3=d1; System.out.println(d1.euqals(d3)); System.out.println(d1==d2); System.out.println(d1==d3); Demo d4=new Demo(9); Demo d5=new Demo(9); System.out.println(d4.euqals(d5)); System.out.println(d4); } }
内部类
概念:将一个类定义在另一个类的里面,对里面那个类就称为内部类(内置类,嵌套类)。
内部类的 访问规则:
1、内部类可以直接访问外部类中的成员,包括私有成员。
之所以可以直接访问外部类中的成员,是因为内部类中持有了一个外部类的引用,格式 外部类名.this
2、外部类要访问内部类,必须建立内部类对象。
访问内部类的 格式:
1、当内部类定义在外部类的成员位置上,而且非私有,可以在外部其他类中,可以直接建立内部类对象。
格式:外部类名.内部类名 变量名=外部类对象.内部类对象
示例代码如下:
class Outer{ private int x=1;//想要让内部类访问到这个,需要将function中的x改成Outer.this.x //如果内部类没有与x重名的变量,那么省略Outer.this也行,前面会默认添加。 class Inner{ int x=2; //想要访问到Inner的成员变量x,function中的打印语句中的x需要改成this.x public void function(){ int x=3; System.out.println("Inner:"+this.x); } } void method(){ Inner in=new Inner(); in.function(); } } public class Demo{ public static void main(String[] args){ Outer out=new Outer(); out.method(); /* //直接访问内部类中的成员 Outer.Inner in=new Outer().new Inner(); //内部类直接创建对象的方式 in.function(); */ } }
2、当内部类在成员位置上,就可以被成员修饰符所修饰
比如:private:将内部类在外部类中进行封装。
static:内部类就具备被static的特性。当内部类被静态static修饰后,只能直接访问外部类中的static成员,出现了访问局限
在外部其他类中,如何直接访问static内部类的非静态呢?
示例代码如下:
class Outer{ private static int x=3; static class Inner{ void function(){ System.out.println("inner:"+x); } } } class Demo{ public class void main(String[] args){ new Outer.Inner().function(); } }
在外部其他类中,如何直接访问static内部类的静态呢?
示例代码如下:
class Outer{ private static int x=3; static class Inner{ static void function(){ System.out.println("inner:"+x); } } } class Demo{ public class void main(String[] args){ Outer.Inner.function(); } }
</pre></p></blockquote></p></blockquote></blockquote><blockquote style="margin: 0 0 0 40px; border: none; padding: 0px;"><p><blockquote style="margin: 0 0 0 40px; border: none; padding: 0px;"><p>注意:1、当内部类中定义了静态static成员,该内部类必须是静态static的2、当外部类中的静态方法访问内部类时,内部类也必须是静态的。示例代码如下:</p></blockquote></p></blockquote><blockquote style="margin: 0 0 0 40px; border: none; padding: 0px;"><blockquote style="margin: 0 0 0 40px; border: none; padding: 0px;"><p><blockquote style="margin: 0 0 0 40px; border: none; padding: 0px;"><p><pre name="code" class="java">class Outer{ private static int x=3; static class Inner{ void function(){ System.out.println("inner:"+x); } } } class Demo{ public class void main(String[] args){ new Outer.Inner().function(); } } class Outer{ private static int x=3; static class Inner{ static void function(){ System.out.println("inner:"+x); } } class Inner2{ void show(){ System.out.println("inner2 show"); } } public static void method(){ Inner.function(); } } class Demo{ public class void main(String[] args){ } }
内部类定义原则:当描述事物时,事物的内部还有事物,该事物用内部类来描述,因为内部事物在使用外部事物的内容。
匿名内部类
1、匿名内部类其实就是内部类的简写格式
2、定义匿名内部类的前提:内部类必须是继承一个类或者实现接口。
匿名内部类其实就是匿名子类对象。
匿名内部类的方法不要超过3个,不利于阅读。
匿名内部类的用法:作为参数传入方法
示例代码如下:
interface Inter{ void method(); } class Test{ //补足代码 static Inter function(){ return new Inter(); public void method(){ System.out.println("method run"); } } } public class Demo{ public static void main(String[] args){ //Test.function():Test类中有一个静态的方法fuction //method方法:function这个方法运算后的结果是一个对象,而且是一个Inter类型的对象 //因为只有是Inter类型的对象,才可以调用method方法。 Test.function().method(); show(new Inter(){ public void method(){ System.out.println("method show run"); } }); } public static void show(Inter in){ in.method(); } }