【本人秃顶程序员】Java核心技术——继承与多态、重载与重写、抽象类与接口

青旅半醒 2022-02-20 10:17 91阅读 0赞

←←←←←←←←←←←← 快！点关注

![1240][]

# 前言 #

前面简单学习了面向对象的知识,知道了其两个重要的特性,继承与多态,今天就围绕着面向对象的这两个特性,将继承与多态及相关的几个几个定义重载与重写,抽象类与接口的相关知识具体学习一下。

# 类的继承 #

关于类的继承定义,前面多少都有些了解了,可以简单的理解为父亲和儿子的关系,儿子会继承父亲的属性和方法,父亲就是父类,儿子就是子类.他们的关系就是继承关系。

> 继承是面向对象的重要观念,它的作用是巨大的,它使得程序架构具有一定的弹性,在程序中复用一些已经定义完善的类可以减少软件的开发周期,也可以提高软件的可维护性.

## extends和implements关键字 ##

在Java语言中继承可以使用 extends 和 implements (用于继承接口)这两个关键字来实现.

> 需要注意的是JAVA语言所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。

Java语言中,类的继承是单一性的,即entends只能单一继承一个类.而implements的存在就是变相的实现了多继承,即一个类可以继承多个接口.接口会在后面讲到。

实例代码

package java02.day_4_12;
    import My_tools.Boundlinetool;
    import My_tools.FormatTimetool;
    /**
     * @outhor xiaoshe
     * @date 2019/4/12  - @time 21:36
     */
    public class sty_extends {
    	public
    	 static void main(String[] args) {
    		father father = new father("小舍的父亲", "工人");
    		son son = new son("小舍", "男", "程序员");
    		System.out.println(father.getName());
    		father.work();
    		Boundlinetool.Minus();
    		System.out.println(son.getName());
    		son.work();
    	}
    }
    // 构建父类
    class father{
    	private String name;
    	private String work;
    	// 成员方法
    	public String getName() {
    		return name;
    	}
    	public String getWork() {
    		return work;
    	}
    	public void setName(String name) {
    		this.name = name;
    	}
    	public void setWork(String work) {
    		this.work = work;
    	}
    	//构造方法
    	public  father(String name,String work){
    		this.work=work;
    		this.name=name;
    	}
    	// 新增方法
    	public void work(){
    		System.out.println(this.work);
    	}
    }
    // 构建子类
    class son extends father{
    	// 通过extends 继承父类
    	private String sex;
    	// 添加新属性.
    	// 重写构造方法,属性不仅继承了父类属性,还将新属性添加其中.
    	public son(String name, String sex,String work) {
    		super(name, work);
    		this.sex=sex;
    	}
    	@Override
    	    // 直接调用父类的成员方法,获取和设置成员属性.
    	public String getName() {
    		return super.getName();
    	}
    	// 重写父类的work方法
    	@Override
    	    public void work(){
    		System.out.println("子类"+super.getName()+"的工作是:");
    		// 重写内容
    		super.work();
    		// 直接调用父类方法.
    	}
    }

# 重写(Override)与重载(Overload) #

## 重写 ##

就是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

我们在类的继承中知道子类不仅可以继承父类的属性方法,还可以定义自己的属性和方法,并且还可以对父类的方法进行重写,来实现自己的需求.重写在面向对象的思想里占重要的地位.它使程序具有了非常良好的扩展性.可以说能够通过重写方法解决一切问题.重写可以说是继承的一种特性.

// 重写父类的work方法
    @Override
        public void work(){
    	System.out.println("子类"+super.getName()+"的工作是:");
    	// 重写内容
    	super.work();
    	// 直接调用父类方法.
    }

## 重载 ##

重载就是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

就是说在类中方法的构建时,可以构建方法名相同而参数不同的方法,这就是方法的重载,重载在类的构造方法中使用的十分常见,我们经常会使用到某些类的构造方法,而且我们会发现通常情况下构造方法都会有很多个,可以通过不同类型的参数构建对象.这就是方法的重载.

![1240 1][]

## 多态 ##

多态就是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口，使用不同的实例而执行不同操作.其实继承,重写就是多态的一种体现,我们可以通过不同的子类重写父类的同一个方法来实现不同的结果.

**多态的特性**:

*  消除类型之间的耦合关系
 *  可替换性
 *  可扩充性
 *  接口性
 *  灵活性
 *  简化性

多态存在的必要条件,就是继承,重写,父类引用指向子类对象.当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

**多态的好处**：

可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

多态最常见的实现方式就是通过重写,或继承接口然后实现接口里的方法(其实就是通过重写接口里的方法来实现不同的作用).

# 抽象类和接口 #

## 抽象类 ##

> 在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

*  抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法的访问方式和普通类一样。
 *  由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。
 *  父类包含了子类集合的常见的方法，但是由于父类本身是抽象的，所以不能使用这些方法。
 *  在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口。

实例代码

package java02.day_4_12;
    /**
     * @outhor xiaoshe
     * @date 2019/4/13  - @time 0:55
     * 抽象类
     */
    public class sty_Polymorphism {
    	public static void main(String[] args) {
    		woman woman = new woman("女", "黄");
    		// 尽管不能实例抽象类,但可以实例其子类对象.
    		System.out.println(woman.getSex());
    		// 可以直接调用抽象类允许的方法.
    		System.out.println( woman.getColor());
    		// 可以直接调用抽象类允许的方法.
    	}
    }
    // 定义抽象类人类
    abstract class humanity{
    	// abstact关键字用来定义抽象类
    	private String sex;
    	private String color;
    	public String getSex() {
    		return sex;
    	}
    	public String getColor() {
    		return color;
    	}
    	public void setSex(String sex) {
    		this.sex = sex;
    	}
    	public void setColor(String color) {
    		this.color = color;
    	}
    	humanity(String sex,String color){
    		//构造方法
    		this.color=color;
    		this.sex=sex;
    	}
    	@Override
    	    public String toString() {
    		//重写toString方法
    		return("性别:"+this.sex+"肤色:"+this.color);
    	}
    }
    class woman extends humanity{
    	// 继承抽象类.woman类可以作为humanity类的一个对象,这就是向上转型.
    	woman(String sex, String color) {
    		// 必须要有构造方法.
    		super(sex, color);
    	}
    }

## 接口 ##

> 接口（英文：Interface），在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。

*  需要注意的是:接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
 *  除非实现接口的类是抽象类，否则当该类继承这个接口后要定义接口中的所有方法。
 *  接口同样无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。

**接口和类的区别**:

*  接口不能用于实例化对象。
 *  接口没有构造方法。
 *  接口中所有的方法必须是抽象方法。
 *  接口不能包含成员变量，除了 static 和 final 变量。
 *  接口不是被类继承了，而是要被类实现。
 *  接口支持多继承。

**接口的特性**:

*  接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract.
 *  接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量
 *  接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

**抽象类和接口的区别**:

*  抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
 *  抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
 *  接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
 *  一个类只能继承一个抽象类，而一个类却可以实现多个接口。

**关于抽象方法**:

抽象方法就是只有方法名,而没有实现方法的方法体,需要在实现类里重写方法体来实现的方法.

public void work(String work);

**接口的定义**:  
和了id定义类似的接口通过inteface关键字来定义.

interface man{
    	public void eat();
    	public void work();
    	public void play();
    }

接口默认就是抽象的(abstract),所以不能实例化,接口的使用,必须被继承,并且其中的方法必须全部被定义实现.才能使用.

实例代码

package java02.day_4_12;
    /**
     * @outhor xiaoshe
     * @date 2019/4/13  - @time 1:35
     */
    public class sty_interface {
    	public static void main(String[] args) {
    		// 然后可以通过实例化接口的实现类的对象,来调用其方法,
    		achieveman achieveman = new achieveman();
    		achieveman.eat();
    		achieveman.work();
    	}
    }
    // 定义一个man接口
    interface man{
    	public void eat();
    	// 抽象方法
    	public void work();
    }
    class achieveman implements man {
    	// 继承接口后,接口内的方法必须的全部实现
    	@Override
    	    public void eat() {
    		System.out.println("男人吃饭");
    	}
    	@Override
    	    public void work() {
    		System.out.println("男人工作");
    	}
    }

# 读者福利： #

**分享免费学习资料**

**针对于Java程序员，我这边准备免费的Java架构学习资料（里面有高可用、高并发、高性能及分布式、Jvm性能调优、MyBatis，Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多个知识点的架构资料）**

**为什么某些人会一直比你优秀，是因为他本身就很优秀还一直在持续努力变得更优秀，而你是不是还在满足于现状内心在窃喜！希望读到这的您能点个小赞和关注下我，以后还会更新技术干货，谢谢您的支持！**

**资料领取方式：加入Java技术交流群`963944895`，私信管理员即可免费领取**

[1240]: /images/20220220/66d26a4a5ce4450c9382b1d660b31e7c.png
[1240 1]: /images/20220220/fdceb5efec2849999ed5e731c96ef6b0.png