5. 继承、抽象类及接口

最新推荐文章于 2024-06-14 00:25:58 发布

我超爱写bug

最新推荐文章于 2024-06-14 00:25:58 发布

阅读量861

点赞数 22

文章标签： java

本文链接：https://blog.csdn.net/muLanlh/article/details/134931274

版权

1.类的继承

1.1.继承的概述

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

1.2.继承格式

• 通过extends关键字可以实现类与类的继承
• class <子类名> extends <父类名> {方法体}
• 单独的这个类称为父类，基类或者超类；这多个类可以称为子类或者派生类。
• 子类只能继承父类所有非私有的成员(成员方法和成员变量),子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法。

1.3.继承的效果

• 扩展功能
• 提高代码复用率
• 让类与类之间产生了关系，是多态的前提
• 增强了类的耦合性

1.4.继承的特点

• Java只支持单继承，不支持多继承;
• Java支持多层继承(继承体系).

1.5.super关键字

• 调用父类构造方法
• 调用父类成员方法
• 调用父类成员变量

1.6.使用继承注意事项

• 子类中所有的构造方法默认都会访问父类中空参数的构造方法。
子类中要使用父类成员变量, 因为子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化。
• 如果父类没有无参构造方法,子类怎么办?

在父类中添加一个无参的构造方法
子类通过super去显示调用父类其他的带参的构造方法
子类通过this去调用本类的其他构造方法,本类其他构造也必须首先访问了父类构造

• 子类中的成员变量和父类中的成员变量名称一样时,在子类中访问一个变量的查找顺序是怎样的?

在子类的方法的局部范围找,有就使用
在子类的成员范围找,有就使用
在父类的成员范围找,有就使用
如果还找不到,就报错

2.方法的重写

2.1.什么是方法重写?

子类中出现了和父类中一模一样的方法声明(方法名,参数列表,返回值类型)，也被称为方法覆盖，方法复写。

2.2.方法重写(Override)和方法重载(Overload)的区别?

Override是覆盖的意思，也就是重写，它与返回值类型无关，只看参数列表;
Overload是重载的意思，表示在同一个类中，允许存在一个以上的同名函数，只要他们的参数个数或者参数类型不同即可;
两者不同主要体现在：目的不同、范围不同、参数要求不同、返回类型不同。
• 同:overload用于增加程序的可读性(做法不同,但是做的同一事情)。 override用于提供其超级类已经提供的方法的特定实现。
• 同:overload 在相同的类范围内内执行。 override发生在两类具有继承（继承）的关系。
• 参数要求不同:overload参数必须不同。 override参数必须相同。
• 返回类型不同:overload中可以相同或不同。 override必须是相同的或协变的。

2.3.方法重写的应用?

当子类需要父类的功能，但是父类功能不满足自身的时候,可以重写父类中的方法。

2.4.方法重写的注意事项

• 父类中私有方法不能被重写。因为父类私有方法子类根本就无法继承；
• 子类重写父类方法时，访问权限不能更低。最好就一致
• 子类重写父类方法时，如果父类方法带有异常,则子类异常范围必须一致或更小
• 子类重写父类方法的时候，最好声明一模一样

3.final关键字

1).final修饰类
被修饰类不能被继承.
2).final修饰方法
被修饰的方法不能被重写.
3).final修饰变量
①局部变量——基本类型
基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。

public class FinalDemo1 {
public static void main(String[] args) {
		// 声明变量，使用final修饰
		final int a;
		// 第一次赋值
		a = 10;
		// 第二次赋值
		a = 20; // 报错,不可重新赋值
		// 声明变量，直接赋值，使用final修饰
		final int b = 10;
		// 第二次赋值
		b = 20; // 报错,不可重新赋值
	}
}

② 局部变量——引用类型
引用类型的局部变量，被final修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的修改。

public class FinalDemo2 {
	public static void main(String[] args) {
		// 创建 User 对象
		final User u = new User();
		// 创建 另一个 User对象
		u = new User(); // 报错，指向了新的对象，地址值改变。
		// 调用setName方法
		u.setName("张三"); // 可以修改
	}
}

③成员变量
成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：
显式初始化：

public class User {
    final String USERNAME = "张三";
	private int age;
}

构造方法初始化：

public class User {
		final String USERNAME ;
		private int age;

		public User(String username, int age) {
			this.USERNAME = username;
			this.age = age;
	}
}

被final修饰的常量名称，一般都有书写规范，所有字母都大写。

3.对象创建过程

• 创建父类对象（父类对象创建也是如此）
• 加载类对象 : 静态代码块
• 默认初始化成员变量
• 显式初始化成员变量
• 实例代码块
• 构造方法
//对象创建的过程
// 0.按照1~5顺序构造父类，但依次先类加载所有类型
// 1.类加载:静态代码块
// 2.默认初始化成员变量
// 3.显式初始化成员变量
// 4.实例代码块
// 5.构造方法

4.抽象类

1).抽象类的基本概念
普通类是一个完善的功能类，可以直接产生实例化对象，并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面增加抽象方法的组成部分。
那么什么叫抽象方法呢？在所有的普通方法上面都会有一个“{}”，这个表示方法体，有方法体的方法一定可以被对象直接使用。而抽象方法，是指没有方法体的方法，同时抽象方法还必须使用关键字abstract做修饰。
拥有抽象方法的类就是抽象类，抽象类要使用abstract关键字声明。
2).定义一个抽象类

abstract class A{//定义一个抽象类
	
	public void fun(){//普通方法
		System.out.println("存在方法体的方法");
	}
	
	public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰
	
}

3).抽象类特点

抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法);
抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；
抽象类要使用必须依靠子类，使用extends继承，一个子类只能继承一个抽象类；
一个类继承了抽象类,则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。）；
抽象类不能用final声明,抽象方法也不能.

5.接口

1).接口的基本概念
官方解释：Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。
通俗解释：接口可以理解为一种特殊的抽象类，里面全部是由全局常量和公共的抽象方法所组成。接口是解决Java无法使用多继承的一种手段，但是接口在实际中更多的作用是制定标准的。或者我们可以直接把接口理解为100%的抽象类，既接口中的方法必须全部是抽象方法。
2).定义一个接口
声明一个接口，使用interface这个关键字，在接口中的所有方法都必须只声明方法标识，而不要去声明具体的方法体，因为具体的方法体的实现是由继承该接口的类来去实现的，因此，接口并不用管具体的实现。一个类实现这个接口必须实现这个接口中定义的所有的抽象方法。实现接口用implements 关键字.

public interface Door {
    void open();
    void close();
}

class A implements Door{

    @Override
    public void open() {
        System.out.println("具体实现open");
    }

    @Override
    public void close() {
        System.out.println("具体实现close");
    }
}

3).接口的特点

接口不能被实例化;
接口中的成员方法默认修饰为public abstract,成员变量默认修饰为public static final;
接口没有构造方法;
一个类可以实现多个接口,格式如: class A implements B,C{ }
接口不能用final声明.

6.类和接口的区别

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

7.抽象类和接口的区别

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

8. 类、接口和抽象类的总结

思想（关键）

类、抽象类、接口都是类:
类是完全具体(不能包含抽象成分)
抽象类是半抽象半具体
完全抽象的（不能包含具体的方法）
抽象类一般体现一种共性，天生就被继承
接口体现一种规范，代表一些能力的集合。

语法：

抽象类用abstract修饰，只能单继承
抽象类中的方法必须加 abstract 修饰符，访问权限不能是 private
接口的方法默认是就是 public，可以省略 abstract 关键字
接口只能声明常量，接口中的成员变量没人就是 public staic final …
接口之间允许多继承

我超爱写bug

关注

22
点赞
踩
27

收藏

觉得还不错? 一键收藏
打赏
0
评论
5. 继承、抽象类及接口

子类中出现了和父类中一模一样的方法声明(方法名,参数列表,返回值类型)，也被称为方法覆盖，方法复写。类、抽象类、接口都是类:类是完全具体(不能包含抽象成分)抽象类是半抽象半具体完全抽象的（不能包含具体的方法）抽象类一般体现一种共性，天生就被继承接口体现一种规范，代表一些能力的集合。
复制链接

扫一扫