/*多态的体现*/
//多态的体现形式：父类的引用指向了子类对象
一个对象对应多种形态造成了：
Animal c=new Cat();
//多态提高了代码的扩展性：
public static void function(Animal a)
{
a.eat();
}
/*多态的前提*/
1.必须是类与类之间有关系，要么是继承要么是实现。
2.必须存在覆盖，即父类特有的抽象方法，子类特有的特性不能代表父类
/*多态的好处*/
多态的出现大大提高了程序的扩展性
/*多态的弊端*/
只能使用父类的引用访问父类中的成员.
Animal c=new Cat()
/*多态的转型*/
//向上转型
Animal c=new Cat(); //将猫向上转型成动物
但有一个问题，当我需要用到子类当中特有的方法时，Animal类中的c显然做不到,
怎么办呢？ 利用向下转型实现
Cat a=(Cat)c; //这样的c和a仍然是同一个对象
/*多态出现的特点*/
class Fu
{
void method1()
{
System.out.println("Fu method-1");
}
void method2()
{
System.out.println("Fu method-2");
}
}
class Zi extends Fu
{
void method1()
{
System.out.println("Zi method-1");
}
void method3()
{
System.out.println("Zi method-3");
}
}
class Q1
{
public static void main(String[] args)
{
Zi z=new Zi();
z.method1();
z.method2();
z.method3(); //打印结果为：Zi 1,Fu 2,Zi 3
Fu f=new Zi();
f.method1();
f.method2();
//f.method3(); //编译失败
}
}
//注：为什么会失败，在Fu f=new Zi()中，javac(编译时期)中的对象还不存在
//单看Fu f中并没有method3()这个方法，所以编译失败
//运行过程，看new Zi()的方法内容。
/*非静态成员函数，成员变量，静态成员函数在多态调用时的特点*/
1.非静态成员函数：Fu f=new Zi()，编译看左边运行看右边；
2.成员变量：(注：成员变量不存在覆盖重写)，f.num和z.num的均看左边；
3.静态成员函数：（用static修饰），f.method和z.method均看左边，原理是：对于static来说是随着类的加载而加载与对象无关，
所以只看左边。
class Animal
{
public void eat()
{
System.out.println("吃饭");
}
public void sleep()
{
System.out.println("睡觉");
}
}
class Dog extends Animal
{
public void eat()
{
System.out.println("吃骨头");
}
public void sleep()
{
System.out.println("站着睡觉");
}
}
class AnimalTool
{
public static void function(Animal a)
{
a.eat();
a.sleep();
}
}
class Q1
{
public static void main(String[] args)
{
Dog d=new Dog(); //不需要非要用Animal d=new Dog()形式来建立对象，直接本类建立对象即可，
AnimalTool.function(d); //因为有继承关系，并且子类调用的为父类引用
}
}
/*接口多态事例*/
interface PCI //通过接口PCI制定规则，在规则允许的情况下向外扩展
{
public void open(); //"扩展"或"制定规则"相当于"使用多态"
public 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 Q1
{
public static void main(String[] args)
{
MainBoard mb=new MainBoard();
mb.run();
mb.usePCI(new NetCard());
}
}
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");
}
}
/*object类*/
object类：object类是所有类直接或间接的父类
/*Object类中的方法 equals */
/*equals*/
class Demo //extends Object //并不需要写出 extends Object，因为所有的类都是Object类的子类或间接子类
{
//super();
}
class Q1
{
public static void main(String[] ags)
{
Object d1=new Demo();
Object d2=new Demo();
boolean a=d1.equals(d2);
System.out.println(a);
System.out.println(d1.equals(d2)); //两者直接进行比较
int x=3;
System.out.println(d1.equals(x)); //结果是false 可见不同类也是可以相互比较的
}
}
/*equals与==的区别*/
System.out.println(d1.equals(x)); //equals可以进行不同类别的比较
System.out.println(d1==x); //==只能进行同类的比较
/*instanceof*/
//instanceof用于判断前者个体是否属于后者类
class Demo
{
}
class Q1
{
public static void main(String[] args)
{
Demo d=new Demo();
boolean b=d instanceof Demo; //结果为boolean类型，格式：单位 instanceof 类别
System.out.println(b);
System.out.println(d instanceof Demo);
}
}
/*Object类中的toString()方法*/
class Demo
{
}
class Q1
{
public static void main(String[] args)
{
Demo d=new Demo();
String x="我是阿秋";
System.out.println(x.toString()); //本类打印只能是String类型
System.out.println(d.toString()); //将类中对象打印就是 类名@哈希值
System.out.println(d.hashCode());
}
}
/*java中API的显示构造*/
public String toString() //public表示该方法可以直接调用，该方法的返回值是String类型
public int hashCode() //直接调用，返回值是int类型
/*一般要使用toString显示其他格式时，需要用到覆盖操作*/
public String toString()
{
return "Demo"+num;
}
|
|
收藏
淘帖
踩
