Java基础系列（八）继承、抽象类

快来打我* 2021-09-26 13:54 323阅读 0赞

### 继承、抽象类 ###

*  一、继承
 *   *  1.1、继承的格式&使用
     *  1.2、继承的好处和注意事项
     *  1.3、继承后，子类父类成员变量的特点
     *  1.4、继承重写
 *  二、抽象
 *   *  2.1、抽象类的定义
     *  2.2、抽象类的特点：
     *  2.3、抽象类的细节：

# 一、继承 #

## 1.1、继承的格式&使用 ##

在程序中，如果想声明一个类继承另一个类，需要使用 `extends` 关键字

class 子类 extends 父类 { }

通过一个案例来学习子类是如何继承父类的：

/* * 定义员工类Employee */
    class Employee { 
    	String name; // 定义 name 属性
    	// 定义员工的工作方法
    	public void work() { 
    		System.out.println("尽心尽力地工作");
    	}
    }
    /* * 定义研发部员工类 Developer 继承员工类 Employee */
    class Developer extends Employee { 
    	// 定义一个打印 name 的方法
    	public void printName() { 
    		System.out.println("name=" + name);
    	}
    }
    
    /* * 定义测试类 */
    public class Example01 { 
    	public static void main(String[] args) { 
    		Developer d = new Developer(); // 创建一个研发部员工类对象
    		d.name = "小明"; // 为该员工类的 name 属性进行赋值
    		d.printName(); // 调用该员工的 printName() 方法
    		d.work(); // 调用 Developer 类继承来的 work() 方法
    	}
    }
    /* 运行结果： name=小明 尽心尽力的工作 */

这就说明，子类在继承父类的时候，会自动拥有父类共有的成员

## 1.2、继承的好处和注意事项 ##

继承的好处：

1.  继承的出现提高了代码的复用性，提高软件开发效率。
2.  继承的出现让类与类之间产生了关系，提供了多态的前提

继承中要注意的问题：  
（1）在 `Java` 中，类只支持单继承，不允许多继承，也就是说一个类只能有一个直接父类

class A{ } 
    class B{ }
    class C extends A,B{ }  // C 类不可以同时继承 A 类和 B 类

（2）多个类可以继承一个父类

class A{ }
     class B extends A{ }
     class C extends A{ }   // 类 B 和类 C 都可以继承类 A

（3）在 Java 中，多层继承是可以的，即一个类的父类可以再去继承另外的父类

class A{ }
     // 类 B 继承类 A，类 B 是类 A 的子类
     class B extends A{ }   
     // 类 C 继承类 B，类 C 是类 B 的子类，同时也是类 A 的子类
     class C extends B{ }

## 1.3、继承后，子类父类成员变量的特点 ##

class Fu
    { 
    	// Fu 中的成员变量。
    	int num = 5;
    }
    class Zi extends Fu
    { 
    	// Zi 中的成员变量
    	int num2 = 6;
    	// Zi 中的成员方法
    	public void show()
    	{ 
    		// 访问父类中的 num
    		System.out.println("Fu num="+num);
    		// 访问子类中的 num2
    		System.out.println("Zi num2="+num2);
    	}
    }
    class Demo 
    { 
    	public static void main(String[] args) 
    	{ 
    		Zi z = new Zi(); // 创建子类对象
    		z.show(); // 调用子类中的 show 方法
    	}
    }

代码说明：`Fu` 类中的成员变量是非私有的，子类中可以直接访问，若Fu类中的成员变量私有了，子类是不能直接访问的。  
    当子父类中出现了同名成员变量时，在子类中若要访问父类中的成员变量，必须使用关键字 `super` 来完成。

class Fu
    { 
    	// Fu 中的成员变量。
    	int num = 5;
    }
    class Zi extends Fu
    { 
    	// Zi 中的成员变量
    	int num = 6;
    	void show()
    	{ 
    		// 子父类中出现了同名的成员变量时
    		// 在子类中需要访问父类中非私有成员变量时，需要使用 super 关键字
    		// 访问父类中的 num
    		System.out.println("Fu num="+super.num);
    		// 访问子类中的 num2
    		System.out.println("Zi num2="+this.num);
    	}
    }
    class Demo5 
    { 
    	public static void main(String[] args) 
    	{ 
    		Zi z = new Zi(); //创建子类对象
    		z.show(); //调用子类中的 show 方法
    	}
    }

## 1.4、继承重写 ##

当在程序中通过对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法

class Fu{ 
    	public void show(){ 
    		System.out.println("Fu类中的show方法执行");
    	}
    }
    class Zi extends Fu{ 
    	public void show2(){ 
    		System.out.println("Zi类中的show2方法执行");
    	}
    }
    public  class Test{ 
    	public static void main(String[] args) { 
    		Zi z = new Zi();
    		z.show(); // 子类中没有 show 方法，但是可以找到父类方法去执行
    		z.show2();
    	}
    }
    /* 运行结果： Fu类中的方法show方法执行 Zi类中的show2方法执行 */

重写  
子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为 `override` 重写、复写或者覆盖

class Fu
    { 
    	public void show()
    	{ 
    		System.out.println("Fu show");
    	}
    }
    class Zi extends Fu
    { 
    	// 子类复写了父类的 show 方法
    	public void show()
    	{ 
    		System.out.println("Zi show");
    	}
    }
    public  class Test{ 
    	public static void main(String[] args) { 
    		Fu z = new Fu(); // 父类对象
    		Fu z1 = new Zi(); // 子类对象
    		z.show(); 
    		z1.show();
    	}
    }

重写注意事项：  
子类方法覆盖父类方法，必须要保证权限大于等于父类权限

class Fu(){ 	
    	void show(){ }
        public void method(){ }
    }
    class Zi() extends Fu{ 
    	public void show(){ }  // 编译运行没问题
        void method(){ }      // 编译错误
    }

# 二、抽象 #

## 2.1、抽象类的定义 ##

// 研发部员工 
    abstract class Developer { 
    	// 抽象函数。需要 abstract 修饰，并分号;结束
    	public abstract void work();
    }
    
    // JavaEE 工程师
    class JavaEE extends Developer{ 
    	public void work() { 
    		System.out.println("正在研发淘宝网站");
    	}
    }
    
    // Android 工程师
    class Android extends Developer { 
    	public void work() { 
    		System.out.println("正在研发淘宝手机客户端软件");
    	}
    }

## 2.2、抽象类的特点： ##

1.  抽象类和抽象方法都需要被 `abstract` 修饰。抽象方法一定要定义在抽象类中。
2.  抽象类不可以直接创建对象，原因：调用抽象方法没有意义。
3.  只有覆盖了抽象类中所有的抽象方法后，其子类才可以创建对象。否则该子类还是一个抽象类。

## 2.3、抽象类的细节： ##

1.  抽象类一定是个父类？  
    是的，因为不断抽取而来的
2.  抽象类中是否可以不定义抽象方法？  
    是可以的，那这个抽象类的存在到底有什么意义呢？不让该类创建对象,方法可以直接让子类去使用
3.  抽象关键字 `abstract` 不可以和哪些关键字共存？  
    （1）`private`：私有的方法子类是无法继承到的，也不存在覆盖，而 `abstract` 和 `private` 一起使用，`abstract` 既要子类去实现这个方法，而 `private` 修饰子类根本无法得到父类这个方法。互相矛盾。  
    （2）`final`，暂时不关注，后面学  
    （3）`static`，暂时不关注，后面学

> **转载请标明出处，原文地址：https://blog.csdn.net/weixin\_41835916  
> 如果觉得本文对您有帮助，请点击顶支持一下，您的支持是我写作最大的动力，谢谢。  
> ![这里写图片描述][70]**

[70]: /images/20210923/20f02056c1b94dca888b71bec083387b.png