JAVA基础---抽象类和接口
文章目录
- 1. 抽象类
-
- 1.1 抽象类概念
- 1.2 抽象类语法
- 1.3 抽象类特性
- 1.4 抽象类的作用
- 2. 接口
-
- 2.1 接口的概念
- 2.2 语法规则
- 2.3 接口使用
- 2.4 接口特性
- 2.5 实现多个接口
- 2.6 接口间的继承
- 2.7 接口使用实例
- 2.8 Clonable 接口
-
- 2.8.1 浅拷贝
- 2.8.2 深拷贝
- 2.9 抽象类和接口的区别
- 3. Object类
1. 抽象类
1.1 抽象类概念
在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。
上图所示中, Animal中的Bark（）方法没有实际工作，把它设计成一个抽象方法(abstractmethod), 包含抽象方法的类（Animal类）我们称为 抽象类(abstract class).
1.2 抽象类语法
在Java中，一个类如果被 abstract 修饰称为抽象类，抽象类中被 abstract 修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。
// 抽象类：被abstract修饰的类
public abstract class 抽象类名称{
// 抽象方法：被abstract修饰的方法，没有方法体
abstract public void draw();
abstract void calcArea();
// 抽象类也是类，也可以增加普通方法和属性
public double getArea(){
return area;
}
protected double area; // 面积
}
1.3 抽象类特性
- 抽象类不能直接实例化对象
Shape shape = new Shape();
// 编译出错
Error:(30, 23) java: Shape是抽象的; 无法实例化
- 抽象方法不能是 private 的
abstract class Shape {
abstract private void draw();
}
// 编译出错
//Error:(4, 27) java: 非法的修饰符组合: abstract和private
- 抽象方法不能被final和static修饰，因为抽象方法要被子类重写
public abstract class Shape {
abstract final void methodA();
abstract public static void methodB();
}
// 编译报错：
// Error:(20, 25) java: 非法的修饰符组合: abstract和final
// Error:(21, 33) java: 非法的修饰符组合: abstract和static
- 抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用 abstract 修饰
public class Shape{
abstract public void draw();
abstract public void calcArea();
}
// 三角形类：
public abstract class Triangle extends Shape {
private double a;
private double b;
private double c;
@Override
public void draw() {
System.out.println("三角形：a = "+a + " b = "+b+" c = "+c);
}
// 三角形：直角三角形、等腰三角形等，还可以继续细化
//@Override
//double calcArea(); // 编译失败：要么实现该抽象方法，要么将三角形设计为抽象类
}
当一个普通类继承了抽象类，那么需要重写该抽象类中的所有方法。
- 抽象类当中和普通类一样，可以定义成员变量和成员方法
abstract class Shape{ //抽象类，使用abstract修饰的类
public String name;//成员方法变量
public static int a;//静态成员变量
public void eat() {//成员方法
System.out.println();
}
public static void draw12(){//静态成员方法
System.out.println();
}
public abstract void draw(); //抽象方法，使用abstract修饰的方法
}
- 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类
- 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量
1.4 抽象类的作用
抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法.
【作用】：
1、定义通用行为：抽象类可以用于定义一组相关类的共同行为。
2、强制子类实现特定行为：抽象类可以包含抽象方法，这些方法没有具体的实现。子类必须实现这些抽象方法，否则子类也必须声明为抽象类。通过抽象方法的存在，抽象类可以强制其子类实现特定的行为，确保子类具有某些必要的功能。
3、提供模板方法：抽象类可以定义模板方法，这些方法提供了算法的框架，但允许子类根据需要实现特定的步骤。
4、限制类的实例化：抽象类不能被实例化，只能被继承，从而限制了该类的直接实例化，只能通过其子类进行实例化。这对于一些希望限制类的实例化和强制子类实现特定行为的情况非常有用。
2. 接口
2.1 接口的概念
接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。
2.2 语法规则
接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口。
public interface 接口名称{
// 抽象方法
public abstract void method1(); // public abstract 是固定搭配，可以不写
public void method2();
abstract void method3();
void method4();
// 注意：在接口中上述写法都是抽象方法，跟推荐方式4，代码更简洁
}
提示:
- 创建接口时, 接口的命名一般以大写字母 I 开头.
- 接口的命名一般使用 “形容词” 词性的单词.
- 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性.
2.3 接口使用
接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法。
public class 类名称 implements 接口名称{
// ...
}
注意：子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系。
2.4 接口特性
- 接口类型是一种引用类型，但是不能直接new接口的对象
public static void main(String[] args) {
Shape shape = new Shape();//err，接口不能被实例化
}
// Error:(10, 19) java: dome2.Shape是抽象的; 无法实例化
- 接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是public abstract，其他修饰符都会报错)
interface Shape {
public void draw();
abstract void draw1();
public abstract void draw2();
void draw3();// 默认被：public abstract 修饰--->建议这样写成员方法，保持代码简洁性
// Error:(4, 18) java: 此处不允许使用修饰符private
private void draw4();
}
- 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现，意味着接口中只能有抽象方法
interface Shape {
// 编译失败：因为接口中的方式默认为抽象方法
// Error:(5, 23) java: 接口抽象方法不能带有主体
void draw(){
System.out.println("打印图案");
}
}
- 重写接口中方法时，不能使用默认的访问权限
public interface Shape{
void draw(); // 默认是public的
}
public class Rect implements Shape{
@Override
void draw() {
System.out.println("矩形");
}
// ...
}
// 编译报错，重写Shape中draw方法时，不能使用默认修饰符
// 正在尝试分配更低的访问权限; 以前为public
- 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量
public interface Shape {
public int a = 1;
public static int b =1;
public final static int c= 0;
int d= 0;// 默认被：final public static修饰--->建议这样写成员变量
void draw();
}
public class Test {
public static void main(String[] args) {
System.out.println(Shape.a); // 可以直接通过接口名访问，说明是静态的
// 编译报错：Error:(12, 12) java: 无法为最终变量a分配值
Shape.a = 2; // 说明brand具有final属性
}
}
- 接口中不能有静态代码块和构造方法
public interface Shape{
// 编译失败
public Shape(){
}
{} // 编译失败
void draw();
}
-
接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
-
接口和接口的实现类之间是implements实现关系，并且实现类要实现接口中的所有抽象方法，如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类
abstract class Rect implements Shape {
// @Override
// public void draw() {
//
// }
}
//编译报错：java: dome.dome2.Rect不是抽象的, 并且未覆盖dome.dome2.Shape中的抽象方法draw()
- jdk8中：接口中还可以包含default方法。
interface Shape {
default void draw() {//可重写，可不重写
}
}
10.接口中可以存在static修饰的方法
public interface ITest {
void testA();
static void testStatic() {//不能被重写
System.out.println("testStatic()");
}
}
2.5 实现多个接口
在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。下面通过类来表示一组动物.
class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
}
另外我们再提供一组接口, 分别表示 “会飞的”, “会跑的”, “会游泳的”.
interface IFlying {
void fly();
}
interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
接下来我们创建几个具体的动物
猫, 是会跑的.
class Cat extends Animal implements IRunning {
public Cat(String name) {
super(name);
}
@Override
public void run() {
System.out.println(this.name + "正在用四条腿跑");
}
}
鱼, 是会游的.
class Fish extends Animal implements ISwimming {
public Fish(String name) {
super(name);
}
@Override
public void swim() {
System.out.println(this.name + "正在用尾巴游泳");
}
}
青蛙, 既能跑, 又能游(两栖动物)
class Frog extends Animal implements IRunning, ISwimming {
public Frog(String name) {
super(name);
}
@Override
public void run() {
System.out.println(this.name + "正在往前跳");
}
@Override
public void swim() {
System.out.println(this.name + "正在蹬腿游泳");
}
}
注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。
还有一种神奇的动物, 水陆空三栖, 叫做 “鸭子”
class Duck extends Animal implements IRunning, ISwimming, IFlying {
public Duck(String name) {
super(name);
}
@Override
public void fly() {
System.out.println(this.name + "正在用翅膀飞");
}
@Override
public void run() {
System.out.println(this.name + "正在用两条腿跑");
}
@Override
public void swim() {
System.out.println(this.name + "正在漂在水上");
}
}
上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口.
继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性 .
猫是一种动物, 具有会跑的特性.
青蛙也是一种动物,既能跑, 也能游泳
鸭子也是一种动物, 既能跑, 也能游, 还能飞
时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型,而只关注某个类是否具备某种能力.
例如, 现在实现一个方法, 叫 “散步”
public static void walk(IRunning running) {
System.out.println("我带着伙伴去散步");
running.run();
}
在这个 walk 方法内部, 我们并不关注到底是哪种动物, 只要参数是会跑的, 就行
Cat cat = new Cat("小猫");
walk(cat);
Frog frog = new Frog("小青蛙");
walk(frog);
// 执行结果
我带着伙伴去散步
小猫正在用四条腿跑
我带着伙伴去散步
小青蛙正在往前跳
2.6 接口间的继承
在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。
接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字.
interface IRunning {
void run();
}
interface ISwimming {
void swim();
}
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
}
class Frog implements IAmphibious {
...
}
通过接口继承创建一个新的接口 IAmphibious 表示 “两栖的”. 此时实现接口创建的 Frog 类, 就继续要实现 run 方法, 也需要实现 swim 方法.接口间的继承相当于把多个接口合并在一起.
2.7 接口使用实例
给对象数组排序
class Student {
private String name;
private int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
}
@Override
public String toString() {
return "[" + this.name + ":" + this.score + "]";
}
}
再给定一个学生对象数组, 对这个对象数组中的元素进行排序(按分数降序).
Student[] students = new Student[] {
new Student("张三", 95),
new Student("李四", 96),
new Student("王五", 97),
new Student("赵六", 92),
};
Arrays.sort(students);
System.out.println(Arrays.toString(students));
// 运行出错, 抛出异常.
Exception in thread "main" java.lang.ClassCastException: Student cannot be cast to java.lang.Comparable
和普通的整数不一样, 两个整数是可以直接比较的, 大小关系明确. 而两个学生对象的大小关系
怎么确定? 需要我们额外指定.
让我们的 Student 类实现 Comparable 接口, 并实现其中的 compareTo 方法
class Student implements Comparable {
private String name;
private int score;
public Student(String name, int score) {
this.name = name;
this.score = score;
}
@Override
public String toString() {
return "[" + this.name + ":" + this.score + "]";
}
@Override
public int compareTo(Object o) {
Student s = (Student)o;
if (this.score > s.score) {
return -1;
} else if (this.score < s.score) {
return 1;
} else {
return 0;
}
}
}
在 sort 方法中会自动调用 compareTo 方法. compareTo 的参数是 Object , 其实传入的就是 Student类型的对象. 然后比较当前对象和参数对象的大小关系(按分数来算).
- 如果当前对象应排在参数对象之前, 返回小于 0 的数字;
- 如果当前对象应排在参数对象之后, 返回大于 0 的数字;
- 如果当前对象和参数对象不分先后, 返回 0;
// 执行结果
[[王五:97], [李四:96], [张三:95], [赵六:92]]
注意事项: 对于 sort 方法来说, 需要传入的数组的每个对象都是 “可比较” 的, 需要具备 compareTo 这样的能力. 通过重写 compareTo 方法的方式, 就可以定义比较规则.
为了进一步加深对接口的理解, 我们可以尝试自己实现一个 sort 方法来完成刚才的排序过程(使用冒泡排序)
public static void sort(Comparable[] array) {
for (int bound = 0; bound < array.length; bound++) {
for (int cur = array.length - 1; cur > bound; cur--) {
if (array[cur - 1].compareTo(array[cur]) > 0) {
// 说明顺序不符合要求, 交换两个变量的位置
Comparable tmp = array[cur - 1];
array[cur - 1] = array[cur];
array[cur] = tmp;
}
}
}
}
sort(students);
System.out.println(Arrays.toString(students));
// 执行结果
[[王五:97], [李四:96], [张三:95], [赵六:92]]
2.8 Clonable 接口
Java 中内置了一些很有用的接口, Clonable 就是其中之一.
Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 “拷贝”. 但是要想合法调用 clone 方法, 必须要先实现 Clonable 接口, 否则就会抛出 CloneNotSupportedException（不支持克隆） 异常.
观察Cloneable接口，发现是一个空接口（标记接口），当一个类实现该接口之后，表明该类是可以被克隆的。
代码示例：
class Animal implements Cloneable { //一定要实现该接口
private String name;
@Override
public Animal clone() {
Animal o = null;
try {
o = (Animal)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return o;
}
}
public class Test {
public static void main(String[] args) {
Animal animal = new Animal();
Animal animal2 = animal.clone();
System.out.println(animal == animal2);
}
}
// 输出结果
// false
2.8.1 浅拷贝
Cloneable 拷贝出的对象是一份 “浅拷贝”,在clone()方法中使用super调用父类clone()方法是浅拷贝
class Money {
public double m = 99.99;
}
class Person implements Cloneable{
public Money money = new Money();
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class TestDemo3 {
public static void main(String[] args) throws CloneNotSupportedException {
Person person1 = new Person();
Person person2 = (Person) person.clone();
System.out.println("通过person2修改前的结果");
System.out.println(person1.money.m);
System.out.println(person2.money.m);
person2.money.m = 13.6;
System.out.println("通过person2修改后的结果");
System.out.println(person1.money.m);
System.out.println(person2.money.m);
}
}
// 执行结果
通过person2修改前的结果
99.99
99.99
通过person2修改后的结果
13.6
13.6
通过clone，我们只是拷贝了Person对象。但是Person对象中的Money对象，并没有拷贝。之后通过person2这个引用修改了m的值后，person1这个引用访问m的时候，值也发生了改变。这里就是发生了浅拷贝。
2.8.2 深拷贝
class Money implements Cloneable{
public double money = 99.9;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class Person implements Cloneable{
public String name;
public int age;
public Money mon = new Money();
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
protected Object clone() throws CloneNotSupportedException {
Person tmp = (Person) super.clone();
tmp.mon = (Money) this.mon.clone();
return tmp;
//return super.clone();
}
}
public class TestDemo3 {
public static void main(String[] args) throws CloneNotSupportedException {
Person person1 = new Person();
Person person2 = (Person) person.clone();
System.out.println("通过person2修改前的结果");
System.out.println(person1.money.m);
System.out.println(person2.money.m);
person2.money.m = 13.6;
System.out.println("通过person2修改后的结果");
System.out.println(person1.money.m);
System.out.println(person2.money.m);
}
}
// 执行结果
通过person2修改前的结果
99.99
99.99
通过person2修改后的结果
99.9
13.6
通过clone，我们拷贝了Person对象，并且拷贝了Person对象中的Money对象。通过person2这个引用修改了拷贝出来m的值后，person1这个引用访问原来的m的时候不会发生改变，还是原来的值。这里就是发生了深拷贝。
总结： 深拷贝和浅拷贝是指在赋值一个对象时，拷贝的深度不同。
在进行深拷贝时，会拷贝所有的属性，并且如果这些属性是对象，也会对这些对象进行深拷贝，直到最底层的基本数据类型为止。这意味着，对于深拷贝后的对象，即使原对象的属性值发生了变化，深拷贝后的对象的属性值也不会受到影响。
相反，浅拷贝只会拷贝对象的第一层属性，如果这些属性是对象，则不会对这些对象进行拷贝，而是直接复制对象的引用。这意味着，对于浅拷贝后的对象，如果原对象的属性值发生了变化，浅拷贝后的对象的属性值也会跟着发生变化。
2.9 抽象类和接口的区别
抽象类和接口都是 Java 中多态的常见使用方式. 都需要重点掌握. 同时又要认清两者的区别(重要!!! 常见面试题).
核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法.
3. Object类
Object是Java默认提供的一个类。Java里面除了Object类，所有的类都是存在继承关系的。默认会继承Object父类。即所有类的对象都可以使用Object的引用进行接收。
范例：使用Object接收所有类的对象，Object类是参数的最高统一类型。
class Person{}
class Student{}
public class Test {
public static void main(String[] args) {
function(new Person());
function(new Student());
}
public static void function(Object obj) {
System.out.println(obj);
}
}
//执行结果：
Person@1b6d3586
Student@4554617c
Object类也存在有定义好的一些方法。如下：
对于整个Object类中的方法需要实现全部掌握。
（1） 获取对象信息
如果要打印对象中的内容，可以直接重写Object类中的toString()方法。
// Object类中的toString()方法实现：
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
（2）对象比较equals方法
在Java中，== 进行比较时：
a.如果 == 左右两侧是基本类型变量，比较的是变量中值是否相同
b.如果 == 左右两侧是引用类型变量，比较的是引用变量地址是否相同
c.如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的
// Object类中的equals方法
public boolean equals(Object obj) {
return (this == obj); // 使用引用中的地址直接来进行比较
}
Person类重写equals方法后，然后比较：
class Person{
private String name ;
private int age ;
public Person(String name, int age) {
this.age = age ;
this.name = name ;
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false ;
}
if(this == obj) {
return true ;
}
// 不是Person类对象
if (!(obj instanceof Person)) {
return false ;
}
Person person = (Person) obj ; // 向下转型，比较属性值
return this.name.equals(person.name) && this.age==person.age ;
}
}
结论：比较对象中内容是否相同的时候，一定要重写equals方法。
（3）hashcode方法
回忆刚刚的toString方法的源码：
// Object类中的toString()方法实现：
public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
我们看到了hashCode()这个方法，它计算了一个具体的对象位置，它是个内存地址。然后调用Integer.toHexString()方法，将这个地址以16进制输出。
hashcode方法源码：
public native int hashCode();
该方法是一个native方法，底层是由C/C++代码写的。我们看不到。
代码示例：我们认为两个名字相同，年龄相同的对象，将存储在同一个位置，如果不重写hashcode()方法，那么将会得到两个不同的位置：
class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}
public class TestDemo4 {
public static void main(String[] args) {
Person per1 = new Person("gaobo", 20) ;
Person per2 = new Person("gaobo", 20) ;
System.out.println(per1.hashCode());
System.out.println(per2.hashCode());
}
}
//执行结果
460141958
1163157884
注意事项：两个对象的hash值不一样。
重写hashcode()方法：
class Person {
public String name;
public int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public int hashCode() {
return Objects.hash(name, age);
}
}
public class TestDemo4 {
public static void main(String[] args) {
Person per1 = new Person("gaobo", 20) ;
Person per2 = new Person("gaobo", 20) ;
System.out.println(per1.hashCode());
System.out.println(per2.hashCode());
}
}
//执行结果
460141958
460141958
注意事项：得到结果，哈希值一样。
结论：
1、hashcode方法用来确定对象在内存中存储的位置是否相同
2、事实上hashCode()在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。