JAVA核心学习：接口、继承与多态（下）

Bertha 。 2022-12-25 05:54 165阅读 0赞

### 文章目录 ###

*  3. 对象类型的转换
 *   *  3.1 类的向上转型
     *  3.2 类的向下转型
 *  4. instanceof关键字
 *  5. 方法的重载
 *  6. 多态
 *  7. 抽象类与接口
 *   *  7.1 抽象类
     *  7.2 接口

# 3. 对象类型的转换 #

## 3.1 类的向上转型 ##

向上转型就是把子类对象赋值给父类类型的变量。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzQyNTc0MDY5_size_16_color_FFFFFF_t_70]  
首先，创建一个Person类：

public class Person {
        
    	public Person(String name) {
        
    		System.out.println("您好，我叫"+name);
    		
    	} 
    }

然后，创建一个Student类，继承Person类：

public class Student extends Person{
        
    
    	public Student(String name) {
        
    		super(name);
    		
    	}
    
    }

最后，在Demo类中进行实例化：

package JAVALearining;
    
    public class Demo {
        
    
    	public static void main(String[] args) {
        
    		Person tom = new Student("tom");
    	}
    
    }

得到结果：

您好，我叫tom

由于向上转型是从一个叫具体的类到较抽象的类，所以它总是安全的。

## 3.2 类的向下转型 ##

向下转型是将较抽象的类转换为较具体的类。

子类对象总是父类的一个实例，但父类对象不一定是子类的实例。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzQyNTc0MDY5_size_16_color_FFFFFF_t_70 1]  
上述图片中可能有错误，具体看下面的例子。新建Doctor类，继承Person类：

public class Doctor extends Person{
        
    
    	public Doctor(String name) {
        
    		super(name);
    		
    	}
    
    }

然后在实例中对Doctor进行实例化：

public class Demo {
        
    
    	public static void main(String[] args) {
        
    		Person tom = new Student("tom");
    		Person jack = new Doctor("jack");
    		
    		Doctor doc = (Doctor)jack;
    		
    	}
    
    }

运行后，系统没有报错。

您好，我叫tom
    您好，我叫jack

讲真，没明白，这么做的意义何在……不强行转换不是也可以输出吗？视频中的例子举的不好，具体可以参考书上P179。

# 4. instanceof关键字 #

使用`instanceof`操作符判断是否一个类实现了某个接口，也可以用它来判断一个实例对象是否属于一个类。语法如下：

myobjcet instanceof ExampleClass

*  myobject：某类的对象引用
 *  ExampleClass：某个类

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzQyNTc0MDY5_size_16_color_FFFFFF_t_70 2]

使用instanceof操作符的表达式返回值为布尔值。如果返回值为true，说明myobject对象为ExampleClass的实例对象；如果返回false，说明myobject对象不是ExampleClass的实例对象。

例子：

public class Computer {
        //电脑
    	
    	public static void main(String[] args) {
        
    		Pad ipad = new Pad();
    		LenovoPad lenovoPad = new LenovoPad();
    		
    		System.out.println("Pad是否继承自电脑："+(ipad instanceof Computer));
    		System.out.println("LenovoPad是否继承自Pad："+(lenovoPad instanceof Pad));
    		System.out.println("LenovoPad是否继承自Computer："+(lenovoPad instanceof Computer));
    		System.out.println("ipad是否继承自LenovoPad："+(ipad instanceof LenovoPad));
    	}
    }
    	
    class Pad extends Computer{
        //平板电脑
    		
    	}
    	
    class LenovoPad extends Pad{
        //联想平板电脑
    		
    	}

结果：

Pad是否继承自电脑：true
    LenovoPad是否继承自Pad：true
    LenovoPad是否继承自Computer：true
    ipad是否继承自LenovoPad：false

# 5. 方法的重载 #

为了让方法名相同而形参不同的构造方法同时存在，必须用到方法重载。  
方法的重载就是在同一个类中允许同时存在一个以上的同名方法，只要这些方法的参数个数或类型不同即可。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzQyNTc0MDY5_size_16_color_FFFFFF_t_70 3]

public class Demo {
        
    	public static void main(String[] args) {
        
    		System.out.println("调用add(int a)方法：" + add(1));
    		System.out.println("调用add(int a, int b)方法：" + add(1, 2));
    		System.out.println("调用add(int a, double b)方法：" + add(1, 2.1));
    		System.out.println("调用add(double b, int a)方法：" + add(1.1, 2));
    
    	}
    
    	static int add(int a) {
        //最普通方法
    		return a;
    	}
    
    	static int add(int a, int b) {
        //定义与第一个方法参数个数不同的方法
    		return a + b;
    	}
    	
    	static int add(int a, double b) {
        //定义与第二个方法参数类型不同的方法
    		return (int)(100);
    	}
    	
    	static int add(double b, int a) {
        //定义与第二个方法参数顺序不同的方法
    		return (int)(-100);
    	}
    
    }

得到结果：

调用add(int a)方法：1
    调用add(int a, int b)方法：3
    调用add(int a, double b)方法：100
    调用add(double b, int a)方法：-100

# 6. 多态 #

利用多态可以使程序具有良好的扩展性，并可以对所有类对象进行通用的处理。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzQyNTc0MDY5_size_16_color_FFFFFF_t_70 4]  
例子：

class Animal {
        
    	void move() {
        
    
    	}
    }
    
    class Fish extends Animal {
        
    	void move() {
        // 重写move方法
    		System.out.println("Swim");
    	}
    }
    
    class Bird extends Animal {
        
    	void move() {
        // 重写move方法
    		System.out.println("Fly");
    	}
    }
    
    public class Demo {
        
    	public static void main(String[] args) {
        
    		Animal tom = new Fish();
    		tom.move();
    
    		tom = new Bird();
    		tom.move();
    	}
    }

得到结果：

Swim
    Fly

可以看到，同样的对象tom调用相同的方法move()，得到不同的结果。  
需要注意的是，第一次实例化和第二次实例化写法不同，如果写法相同会报错。

# 7. 抽象类与接口 #

## 7.1 抽象类 ##

语法如下：

public abstract class Test{
        
    	abstract void testAbstract();
    }

其中，abstract是定义抽象类的关键字。

使用abstract关键字定义的类称为抽象类，而使用这个关键字定义的方法称为抽象方法。抽象方法没有方法体，这个方法本身没有任何意义，除非它被重写，而承载这个抽象方法的抽象类必须被继承，实际上抽象类除了被继承之外没有任何意义。

反过来讲，如果声明一个抽象的方法，就必须将承载这个抽象方法的类定义为抽象类，不可能在非抽象类中获取抽象方法。因此，只要类中有一个抽象方法，此类就被标记为抽象类。

图：抽象类继承关系  
![抽象类继承关系][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzQyNTc0MDY5_size_16_color_FFFFFF_t_70 5]

## 7.2 接口 ##

接口是抽象类的延伸，可以将它看作是纯粹的抽象类，接口中的所有方法都没有方法体。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzQyNTc0MDY5_size_16_color_FFFFFF_t_70 6]  
接口使用interface关键字进行定义，其语法如下：

public interface drawTest{
        
    	void draw();
    }

*  public：接口可以像类一样被权限修饰符修饰，但public关键字仅限用于接口在与其同名的文件中被定义。
 *  interface：定义接口关键字。
 *  drawTest：接口名称。

例子：  
首先，创建一个接口：

public interface DrawInterface {
        
    	public void draw();
    }

接下来，创建四边形类实现接口：（注意，在实现接口后系统会要求重写draw()方法）

public class Quar implements DrawInterface{
        
    
    	@Override
    	public void draw() {
        
    		System.out.println("绘制四边形");
    		
    	} 
    }

同理，创建正方形类：

public class Square implements DrawInterface{
        
    
    	@Override
    	public void draw() {
        
    		System.out.println("绘制正方形");	
    	}
    }

最后，创建Demo类：

public class Demo {
        
    	public static void main(String[] args) {
        
    		DrawInterface d1 = new Quar();
    		d1.draw();
    
    		DrawInterface d2 = new Square();
    		d2.draw();
    
    	}
    
    }

运行后，得到结果：

绘制四边形
    绘制正方形

这两个类没有继承关系，但是却实现了同一个抽象方法。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzQyNTc0MDY5_size_16_color_FFFFFF_t_70]: /images/20221120/0cf7bdab1e5545e7afd9dcddc0d2ca77.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzQyNTc0MDY5_size_16_color_FFFFFF_t_70 1]: /images/20221120/949df58e58cb4f1c8974cb49e5e474e6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzQyNTc0MDY5_size_16_color_FFFFFF_t_70 2]: /images/20221120/7517592adb2243448abeb1de31e2f2d5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzQyNTc0MDY5_size_16_color_FFFFFF_t_70 3]: /images/20221120/b9716eb333b54a94aa90f513358e2320.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzQyNTc0MDY5_size_16_color_FFFFFF_t_70 4]: /images/20221120/9274d6a28b254296805829f511bc096b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzQyNTc0MDY5_size_16_color_FFFFFF_t_70 5]: /images/20221120/48ae386dab46457ba210277a3452ab8e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NpbmF0XzQyNTc0MDY5_size_16_color_FFFFFF_t_70 6]: /images/20221120/59604dbdd69c471ba3469244627e32be.png