抽象类、多态、根父类

抽象类

定义

抽象方法 ：没有方法体的方法。
抽象类：被abstract所修饰的抽的类。

抽象类的语法格式

【权限修饰符】 abstract class 类名{
    
    
    
}
【权限修饰符】 abstract class 类名 extends 父类{
    
    
    
}

抽象方法的语法格式

【其他修饰符】 abstract 返回值类型  方法名(【形参列表】);

注意：抽象方法没有方法体

抽象的使用

继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。

此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

注意事项

抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。
抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。

理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设计。

扫描二维码关注公众号，回复： 12476821 查看本文章
抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。

理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

多态

定义

多态：是指同一行为，具有多个不同表现形式。

前提【重点】

继承父类或者实现接口【二选一】
方法的重写【意义体现：不重写，无意义】
父类引用指向子类对象【格式体现】

多态的体现

多态体现的格式：

父类类型 变量名 = new 子类对象；
变量名.方法名();//这个方法是父类中声明，子类中重写的方法

父类类型：指子类对象继承的父类类型，或者实现的父接口类型。

多态体现出来的现象：

编译时，看“父类”，只能调用父类声明的方法，不能调用子类扩展的方法；

运行时，看“子类”，一定是执行子类重写的方法体；

代码如下：

定义父类：

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

定义子类：

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 class Test {
    
    
    public static void main(String[] args) {
    
    
        // 多态形式，创建对象
        Animal a1 = new Cat();  
        // 调用的是 Cat 的 eat
        a1.eat();    
        //a1.catchMouse();//错误，catchMouse()是子类扩展的方法，父类中没有
        /*
        多态引用，编译时，看“父类”，只能调用父类声明的方法；
        	    运行时，看“子类”，一定是执行子类重写的方法体；
        */

        // 多态形式，创建对象
        Animal a2 = new Dog(); 
        // 调用的是 Dog 的 eat
        a2.eat();               
    }  
}

多态的好处

1.多态参数

实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利。代码如下：

定义父类：

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

定义子类：

class Cat extends Animal {
    
      
    public void eat() {
    
      
        System.out.println("吃鱼");  
    }  
}  

class Dog extends Animal {
    
      
    public void eat() {
    
      
        System.out.println("吃骨头");  
    }  
}

定义测试类：

public class Test {
    
    
    public static void main(String[] args) {
    
    
        // 多态形式，创建对象
        Cat c = new Cat();  
        Dog d = new Dog(); 

        // 调用showCatEat 
        showCatEat(c);
        // 调用showDogEat 
        showDogEat(d); 

        /*
        以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代
        而执行效果一致
        */
        showAnimalEat(c);
        showAnimalEat(d); 
    }

    public static void showCatEat (Cat c){
    
    
        c.eat(); 
    }

    public static void showDogEat (Dog d){
    
    
        d.eat();
    }

    public static void showAnimalEat (Animal a){
    
    
        a.eat();
    }
}

由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以把Cat对象和Dog对象，传递给方法。

当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致，所以showAnimalEat完全可以替代以上两方法。

不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用showAnimalEat都可以完成。

所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。

2.多态数组

例如：家里养了两只猫，两条狗，想要统一管理他们的对象，可以使用多态数组

public class TestAnimal {
    
    
	public static void main(String[] args) {
    
    
		Animal[] all = new Animal[4];//可以存储各种Animal子类的对象
		all[0] = new Cat();
		all[1] = new Cat();
		all[2] = new Dog();
		all[3] = new Dog();
		
		for (int i = 0; i < all.length; i++) {
    
    
			all[i].eat();//all[i]编译时是Animal类型，运行时看存储的是什么对象
		}
	}
}

父子类之间的类型转换

多态的转型分为向上转型与向下转型两种：

向上转型

向上转型：多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。

当父类引用指向一个子类对象时，便是向上转型。

使用格式：

父类类型  变量名 = new 子类类型();
如：Animal a = new Cat();

向下转型

向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。

一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

使用格式：

子类类型 变量名 = (子类类型) 父类变量名;
如:Cat c =(Cat) a;

为什么要转型

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。

转型的异常

转型的过程中，一不小心就会遇到这样的问题，请看如下代码：

public class Test {
    
    
    public static void main(String[] args) {
    
    
        // 向上转型  
        Animal a = new Cat();  
        a.eat();               // 调用的是 Cat 的 eat

        // 向下转型  
        Dog d = (Dog)a;       
        d.watchHouse();        // 调用的是 Dog 的 watchHouse 【运行报错】
    }  
}

instanceof运算符

为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，只要用instanceof判断返回true的，那么强转为该类型就一定是安全的，不会报ClassCastException异常。

格式如下：

变量名/对象 instanceof 数据类型 

如果变量/对象属于该数据类型，返回true。
如果变量/对象不属于该数据类型，返回false。

所以，转换前，我们最好先做一个判断，代码如下：

public class Test {
    
    
    public static void main(String[] args) {
    
    
        // 向上转型  
        Animal a = new Cat();  
        a.eat();               // 调用的是 Cat 的 eat

        // 向下转型  
        if (a instanceof Cat){
    
    
            Cat c = (Cat)a;       
            c.catchMouse();        // 调用的是 Cat 的 catchMouse
        } else if (a instanceof Dog){
    
    
            Dog d = (Dog)a;       
            d.watchHouse();       // 调用的是 Dog 的 watchHouse
        }
    }  
}

属性、静态方法没有多态性

1、属性没有多态性

如果直接访问成员变量，那么只看编译时类型

public class TestField {
    
    
	public static void main(String[] args) {
    
    
		Father f = new Son();
		System.out.println(f.x);//只看编译时类型//1
	}
}
class Father{
    
    
	int x = 1;
}
class Son extends Father{
    
    
	int x = 2;
}

2、静态方法没有多态性

public class TestField {
    
    
	public static void main(String[] args) {
    
    
		Father f = new Son();
		f.test();//只看编译时类型
	}
}
class Father{
    
    
	public static void test(){
    
    
		System.out.println("father");
	}
}
class Son extends Father{
    
    
	public static void test(){
    
    
		System.out.println("son");
	}
}

小贴士：

静态方法不能被重写

调用静态方法最好使用“类名.”

native关键字

native：本地的，原生的
用法：

只能修饰方法

表示这个方法的方法体代码不是用Java语言实现的。

但是对于Java程序员来说，可以当做Java的方法一样去正常调用它，或者子类重写它。

方法区：类的信息、常量、静态变量、动态编译生成的字节码信息

虚拟机栈：Java语言实现的方法的局部变量

本地方法栈：非Java语言实现的方法的局部变量，即native方法执行时的内存区域

堆：new出来的对象

程序计数器：记录每一个线程目前执行到哪一句指令

修饰符一起使用问题？

	外部类	成员变量	代码块	构造器	方法	局部变量
public	√	√	×	√	√	×
protected	×	√	×	√	√	×
private	×	√	×	√	√	×
static	×	√	√	×	√	×
final	√	√	×	×	√	√
abstract	√	×	×	×	√	×
native	×	×	×	×	√	×

不能和abstract一起使用的修饰符？

（1）final：和final不能一起修饰方法和类

（2）static：和static不能一起修饰方法

（3）native：和native不能一起修饰方法

（4）private：和private不能一起修饰方法

static和final一起使用：

（1）修饰方法：可以，因为都不能被重写

（2）修饰成员变量：可以，表示静态常量

（3）修饰局部变量：不可以，static不能修饰局部变量

（4）修饰代码块：不可以，final不能修改代码块

（5）修饰内部类：可以一起修饰成员内部类，不能一起修饰局部内部类（后面讲）

Object根父类

类 java.lang.Object是类层次结构的根类，即所有类的父类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

如果一个类没有特别指定父类，那么默认则继承自Object类。