学习java的第11天

多态性

多态性是指“多种形式”。

为了更好的理解多态性的概念。下面有一个图，一个名为Shape的父类，从该类派生出3个不同的类：Triangle（三角形）、Rectangle(矩形)和Pentagon（五边形）。父类Shape中的方法Draw()在每个子类中都被具体化为画一个特定类型的形状，在前面的讲解中这称为泛化/特化，在编程术语中，这称为“方法重写”。

定义一个对象…obj作为子类…的事例，并用它实现Shape类。这样做是完全可以的，在实现多态性时，可以创建一个带有父类的对象，但该对象的实际实现是…子类的，也就是说可能认为该对象为Shape类型，并且具有…类型的引用，声明这种对象的代码如下：
Shape Pentagon Obj =new Pentagon();
下面是一些代码实例
/*
*

• 代码中体现多态：父类应用指向子类多象

• 格式

• 父类名称 对象名 =new 子类名称 ();

• */
  public class Demo0112Multi {
  public static void main(String[] args) {
  //类型 变量名称=常量
  //int num=5;
  //
  Fu fu =new Fu();
  fu.method();
  fu.methodFu();

  System.out.println("====");
  Zi zi=new Zi();
  zi.method();
  zi.methodFu();
  zi.methodZi();

  System.out.println("====");
  //类似于强制类型转换
  //double num =5f
  Fu obj=new Zi();
  obj.method();//子类方法
  obj.methodFu();
  //obj.methodZi();
  }
  }

public class Fu {
public void method() {
System.out.println(“父类方法”);

}
public void methodFu() {
System.out.println(“子类方法”);
}
}

public class Zi extends Fu{

public void method() {
	   System.out.println("子类方法");
}
public void methodFu() {
	   System.out.println("父类特有方法");

}
public void methodZi() {
System.out.println(“子类特有方法”);
}
}
运行结果

/*

• 访问成员变量的两种方式
• 1.直接通过
• 2.通过成分方法直接访问

*/
public class Demo02MultiField {
public static void main(String[] arge) {
//直接访问 看等号左边是谁，就用谁 没有则向上找
Fu obj=new Zi();
System.out.println(obj.num);//父 10
//System.out.println(obj.age);错误用法
System.out.println("====");
//成员访问法 看该方法属于谁，就用谁
obj.showNum();
}

}

//成员方法

//new 的是谁,就先用谁
//对比
//成员变量 编译看左边 运行还看左边
//成员变量 编译看左边 运行看右边
public class Demo02MultiMethod {
public static void main(String[] args) {
Fu obj=new Zi();

	obj.method();
	//obj.methodFu();
	obj.methodFu();
	
}

}

public class Fu {
int num=10;

public void showNum() {
System.out.println("子类方法"+num);
}
public void method() {
	   System.out.println("父类方法");
	   
   }
   public void methodFu() {
	   System.out.println("子类方法");
   }

}

public class Zi extends Fu{
int num =20;
int age =16;
public void shownum() {
System.out.println(“子类方法”+num);

}
public void methodZi() {
	System.out.println("子类方法");
}

}
运行结果

public abstract class Animal {
public abstract void eat();

}

public class Cat extends Animal{
@Override
public void eat() {
System.out.println(“猫吃鱼”);
}

public void catchMouse() {
	System.out.println("猫抓老鼠");

}
}

public class Demo03Instancof {
public static void main(String[] args) {
Animal animal =new Dog();

	animal.eat();
	giveMeAPet(animal);
}
public static void giveMeAPet(Animal animal)
{
	
	if( animal instanceof Dog)
	{
		Dog dog=(Dog)animal;
		dog.watchHouse();
		
	}
	if( animal instanceof Cat)
	{
		Cat cat=(Cat)animal;
		cat.catchMouse();
		
	}
}

}

//向上类型转换 总是安全的.但是也有缺陷 原来特有功能不能使用
public class Demo03Main {
public static void main(String[] args) {

//类似于 隐式类型转换
Animal animal =new Cat();
animal.eat();
//向下类型转换 由父类型 转换子类型 还原
Cat cat = (Cat) animal;
cat.catchMouse();

}

}

public class Dog extends Animal{
@Override
public void eat() {
System.out.println(“狗吃骨头”);

}
public void watchHouse() {
System.out.println(“狗看门”);
}
}
运行结果

/*

• final

• 1.用来修饰一个类

• 用来修饰一个方法

• 用来修饰一个局部变量

• 用来修饰一个成员变量
  */
  public class Demo04Final {
  private static void main(String[] args) {

   int num1=10;
   System.out.println(num1);
   num1=100;
   System.out.println(num1);
   
   final int num2=200;
   System.out.println(num2);
   final int num3;
   		num3=300;
   System.out.println("===");
   
   Student stu1= new Student("郑志丹");
   System.out.println(stu1);
   System.out.println(stu1.getName());
   
   stu1=new Student("鹿晗");
   System.out.println(stu1);
   System.out.println(stu1.getName());
   
   System.out.println("=====");
   
   final Student stu2=new Student("关晓彤");
   System.out.println(stu2);
   System.out.println(stu2.getName());
   
   stu2.setName("高圆圆");
   System.out.println(stu2);
   System.out.println(stu2.getName());
   
   System.out.println("=====");
   Person person=new Person("鹿晗");
   System.out.println(person.getName());
  

  }

}

//final修饰方法的时候 该方法就是最终方法 不能被重写
public abstract class Fu {
public final void method() {
System.out.println(“父类方法”);
}

public abstract void methodAbs();

}

public class MyClass {
public void method() {
System.out.println(“方法执行”);
}

}

public class MySuClass /extends MyClass/{

}

public class Person {
private final String name;

public Person() {
	name="毛晓彤";
}
public Person(String name) {
	this.name =name;

}
public String getName() {
return name;
}

}

public class Zi extends Fu{
/*
@Override
public void method() {
System.out.println(“子类方法”);
}*/
public void methodAbs() {

}
}

public class Student {
private String name;

public Student() {
	
}
public Student(String name) {
	this.name =name;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name =name;
}

}