直接上代码看:
Pragma mark — NO.1 理解多态--基础代码:
public class Animal {
public static void main(String[] args){
//以前的方法创建猫对象
//这句理解为 创建一个猫对象，猫就是一只猫，不是其它的什么东西
Cat c = new Cat();
c.eat();
//多态的创建方法
// Animal1 a 是声明了一个父类引用，这个引用指向了子类对象。就是说猫是一个动物。 这就是那句要有父类引用指向子类对象
//
Animal1 a = new Cat();
a.eat();//这个的输出结果还是猫要吃鱼
}
}
/*
* 多态概述:事物存在的多种形态
* 多态前提:
* 1.要有继承关系
* 2.要有方法重写
* 3.要有父类引用指向子类对象
*
* */
//定义一个动物类
class Animal1{
//定义一个吃方法
public void eat(){
System.out.println("动物吃法");
}
}
//定义一个猫类继承自Animal
class Cat extends Animal1{
//重写父类的吃的方法
public void eat(){
System.out.println("猫要吃鱼");
}
}
Pragma mark — NO.2 多态成员变量
public class Polymorphic {
public static void main(String[] args){
Father f = new Son();//父类引用指向子类对象
System.out.println(f.num);
//这个打印结果是10; 编译看左边/运行看右边
//解释一下:
/*
* 当我们创建new Son() 子类对象的时候，子类对象可以访问分类的成员变量。
* 是通过super来访问的，对于子类创建好在堆区分配好内存后，就会有两块区域，一块是
* 父类的成员变量显示初始化为10，通过super访问的
* 另一块就是子类自己的成员变量初始化为20
* 对于f.num ,来说这个指针引用是指向father的，所以它只能看到子类中属于自己的
* 那块区域，所以打印为10
**/
//再来
Son s = new Son();
System.out.println(s.num);
}
}
//父类
class Father{
//成员变量
int num = 10;
}
//子类
class Son extends Father{
int num = 20;
}
Pragma mark — NO.3 成员方法
//成员方法:编译看左边/运行看右边
Father f = new Son();
f.print();//打印出来是:我是子类。这个就是动态绑定
//编译的时候，先去找父类有没有这个print方法，如果有，编译通过，然后运行的时候去子类中找这个print方法
//父类
class Father{
//成员变量
int num = 10;
//成员方法
public void print(){
System.out.println("我是父类");
}
}
//子类
class Son extends Father{
int num = 20;
public void print(){
System.out.println("我是子类");
}
Pragma mark — NO.4 静态方法
//静态方法--编译看左边，运行看左边
Father f = new Son();
f.method();//打印我是父类静态方法
class Father{
//成员变量
int num = 10;
//成员方法
public void print(){
System.out.println("我是父类");
}
//静态方法
public static void method(){
System.out.println("我是父类静态方法");
}
}
//子类
class Son extends Father{
int num = 20;
public void print(){
System.out.println("我是子类");
}
//静态方法
public static void method(){
System.out.println("我是子类静态方法");
}
}
Pragma mark — NO.5 超人的例,理解向上和向下转型
public class SuperMan {
public static void main(String[] args){
Person1 p = new Super();//父类引用指向子类对象，可以理解为超人平时伪装为一个普通人
//父类引用指向子类对象就是向上转型:就相当于将super这个子类提升到了父类的层次
//就是说初次见面，超人只会说他是json，来谈生意的，不会是他是超人，但是实际和你谈生意的是超人
System.out.println(p.name);
p.takeMethod();
//然后出现情况，超人要去救人，但是没证明他是超人之前是不会让他去救人的
//p.fly();//这样调用超人的方法是会出错的，因为当前超人是以普通人身份出现的，他就不具备救人的技能
//所以我们想要去救人，就得向人们证明你是超人，所以我们得做一个向下转型
Super s = (Super)p; //这个就是向下转型
System.out.println(s.name);
s.fly();
/*
* 基本数据类型自动类型提升和强制类型转换
* */
int i = 10;
byte b = 20 ;
i = b;//这就是自动类型提升
System.out.println(String.valueOf(i));
//b = i;//直接将int型赋值给byte类型会报错，是把大类型赋值给小类型，会有精度损失
b = (byte)i;//强制类型转换
}
}
//我们通过这个例子描述一个超人的故事
class Person1 {
//平时的时候超人叫json,在谈生意
String name = "我叫Json";
public void takeMethod(){
System.out.println("我来和你谈生意");
}
}
//子类--超人
class Super extends Person1 {
String name = "我是SuperMan";
public void takeMethod(){
System.out.println("我是超人来和你谈生意");
}
//超人特有的方法
public void fly(){
System.out.println("我要去救人了哦");
}
}
Pragma mark — NO.6 多态的好处
public class Main {
public static void main(String[] args) {
//创建猫对象
// Cat c1 = new Cat();
// c1.eat();
//我们想让猫吃的动作执行很多次,我们写个方法
method(new Cat());
//method(new Dog());这样写是错误的，狗是一只猫是不行的塞
method(new Dog());
}
// public static void method(Cat c){
// c.eat();
// }
//
// public static void method1(Dog d){
//
// d.eat();
// }
//看了上面的，思考如果我们还有单独的猪，牛，羊类，意味着这种method方法我们都要去写一遍了。这肯定不好
//想想解决办法
//我们直接传入这个父类，当我们传入参数是子类的时候，就相当于父类引用指向子类对象了
public static void method(Animal a ){
// a.eat();
// //这样写有好的地方，弊端我们看看
// // a.catchMouse();//这个方法是狗类自己的，编译时在父类中找不到，所以不行
// //要使用子类独有的方法，我们可以进行向下转型
// Dog d = (Dog)a;
// d.lookHome();
//介绍一个关键字 instanceof:判断前面的引用是否是后面的类型
if (a instanceof Cat){
Cat c = (Cat)a;
c.eat();
c.catchMouse();
}else {
Dog d = (Dog)a;
d.eat();
d.lookHome();
//开发中很少这样去调用子类的特有方法，比较麻烦
}
}
}
/*
* 多态的好处:
* a:提高了代码的维护性(继承保证)
* b:提高了代码的扩展性(多态保证)
* B:案例演示:
* 多态的好处
* 可以当做形式参数，可以接收任意子类对象
*
* C:多态的弊端:
* 不能使用子类的特有属性和行为
**/
class Animal {
public void eat() {
System.out.println("动物要吃东西");
}
}
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 lookHome(){
System.out.println("狗狗会看家");
}
}
