六、抽象类和接口

最新推荐文章于 2024-06-16 09:46:44 发布

江初。

最新推荐文章于 2024-06-16 09:46:44 发布

阅读量209

点赞数 5

分类专栏： JAVA SE语法文章标签： java java-ee 开发语言

本文链接：https://blog.csdn.net/kt_su/article/details/124775987

版权

JAVA SE语法专栏收录该内容

9 篇文章 0 订阅

订阅专栏

🚀 一、抽象类

🌟 1.1 抽象类的概念

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

🌟 1.2 抽象类语法

在Java中，一个类如果被 abstract 修饰就称为抽象类，抽象类中被 abstract 修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。

// 抽象类：被 abstract 修饰的类
public abstract class Shape {
	// 抽象方法：被 abstract 修饰的方法，没有方法体
	abstract public void draw();
	abstract void calcArea();
	
	// 抽象类也是类，也可以增加普通方法和属性
	public double getArea(){
		return area;
	}
	
	protected double area; // 面积
}

注：抽象类也是类，内部包含普通方法和属性，甚至构造方法。

🌟 1.3 抽象类特性

抽象类不能直接实例化对象。

Shape shape = new Shape();

// 编译出错
Shape 是抽象的无法实例化。

抽象方法不能是 private 的。

abstract class Shape{
	abstract private void draw();
}

// 编译出错
private 和 abstract 非法的修饰符组合。

抽象方法没有限定符时，默认是 public 。
3. 抽象方法不能被 final 和 static 修饰，因为抽象方法要被子类重写。
4. 抽象类必须被继承，继承后要重写父类中所有抽象方法。否则子类也是抽象类，必须 abstract 修饰。
5. 抽象类不一定包含抽象方法，但是有抽象方法的类一定是抽象类。
6. 抽象类中可以有构造方法，供子类创建对象时，初始化父类成员变量。

🌟 1.4 抽象类的作用

抽象类本身不能被实例化，要想使用，只能创建该抽象类的子类，然后让子类重写抽象类中的抽象方法。

// 抽象类 Shape
abstract class Shape{
    public abstract void Draw();
}

class Rect extends Shape{
    @Override
    public void Draw() {
        System.out.println("▢");
    }
}

class Flower extends Shape{
    @Override
    public void Draw() {
        System.out.println("❀");
    }
}

class Cycle extends Shape{
    @Override
    public void Draw() {
        System.out.println("⚪");
    }
}


public class test2 {
	// 多态的一种表现
    public static void drawMap(Shape shape){
        shape.Draw();
    }

    public static void main(String[] args) {
        // 向上转型
        Shape shape = new Rect();
        drawMap(shape);
    }
}

🚀 二、接口

🌟 2.1 接口的概念

Java 中的接口是一种引用数据类型，可以作为多个类的使用规范。

🌟 2.2 语法规则

接口的定义格式与定义类的格式基本相同。

public interface 接口名称{
	// 抽象方法
	public abstract void method();
	public void method2();
	abstract method3();

	void method4();

	// 注意：在接口中上面的写法都是抽象方法，推荐方法4的写法，更加简洁。
}

🌕提示：

接口的名字一般以大写 “ I ” 开头。
接口命名一般是“形容词”词性的单词。
阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性，也就是上面方法四的写法。
接口中的普通方法不能有具体实现，或者可以用 default 来修饰。并且可以有 static 方法。

🌟 2.3 接口使用

接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法。
类和接口之间的关系由 implements 实现。

// Ishape 接口
public interface Ishape{
	// public abstract void
    void draw();
}

// 对象和接口的关系是 implements
class Rect implements Ishape{
    @Override
    public void draw() {
        System.out.println("□");
    }
}

class Flower implements Ishape{
    @Override
    public void draw() {
        System.out.println("❀");
    }
}

🌟 2.4 接口特性

接口是一种引用类型，不能直接被 new 实例化对象。
接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 public abstract（只能是public abstract，其他修饰符都会报错)。
接口中的方法不能在接口中实现，只能由实现接口的类来重写。

public interface USB{
	void openDevice();
	
	// Error:(5, 23) java: 接口抽象方法不能带有主体
	void closeDevice(){
		System.out.println("关闭USB设备");
	}
}

重写接口中方法时，不能使用 default 访问权限修饰。因为子类重写方法的访问权限不能比父类原型低。（一般用 public）
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量。

public interface USB {
	double brand = 3.0; 	// 默认被：final public static修饰
	void openDevice();
	void closeDevice();
}

public class TestUSB {
	public static void main(String[] args) {
		System.out.println(USB.brand); 	// 可以直接通过接口名访问，说明是静态的
		
		// 编译报错：Error:(12, 12) java: 无法为最终变量brand分配值
		USB.brand = 2.0; 	// 说明brand具有final属性
	}
}

接口中不能有静态代码块和构造方法。
接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class。
如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类。

🌟 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("猫猫正在跑");
    }
}

class Fish extends Animal implements ISwimming{
    public Fish(String name){
        super(name);
    }

    @Override
    public void swim() {
        System.out.println("鱼正在游");
    }
}

// 一个类继承一个类，并且实现多个接口，接口间用 “ ， ” 隔开。
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,IFlying,ISwimming{
    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 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口.

🌟 2.6 接口之间的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，但是接口与接口之间可以多继承。即：用接口可以达到多继承的目的。

🌕接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字。

interface IRunning {
	void run();
} 

interface ISwimming {
	void swim();
} 

// 接口之间的继承可以看作把多个接口合并到一起。
interface IAmphibious extends IRunning, ISwimming {
	// ...
}

// 实现 IAmphibious 的类要重写三个接口中的所有抽象方法。
class Frog implements IAmphibious {
	...
	void run(){
		// ...
	}
	void swim(){
		// ...
	}
}

🌟 2.7 接口使用实例

2.7.1 Comparable 比较接口

实现对象数组的排序：

// 对象类要实现 Comparable 接口，并重写 compareTo 方法.
class Student implements Comparable {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

	// 重写的 compareTo 方法
    @Override
    public int compareTo(Object o) {
    	// 自定义比较器
        Student s = (Student)o;
        if(s.age > this.age){
            return -1;
        }
        else if(s.age < this.age){
            return 1;
        }
        else{
            return 0;
        }
        // return s.age - this.age;
    }
}

public class demo1 {
    public static void main(String[] args) {
		// 创建一个对象数组
        Student[] students = new Student[]{
                new Student("张三",23),
                new Student("李四", 96),
                new Student("王五", 97),
                new Student("赵六", 92),
        };
        // 调用排序方法
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
    }
}

在 sort 方法中会自动调用 compareTo 方法. compareTo 的参数是 Object , 其实传入的就是 Student 类型的对象。然后比较当前对象和参数对象的大小关系(按分数来算)。

如果当前对象小于参数对象, 返回小于 0 的数字;
如果当前对象大于参数对象, 返回大于 0 的数字;
如果当前对象和参数对象相等 , 返回 0;

2.7.2 Comparator 比较器

Comparator 比较器

class Student  {
    String name;
    int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

// 年龄比较器
class AgeComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age - o2.age;
    }
}

// 姓名比较器
class NameComparator implements Comparator<Student>{
    @Override
    public int compare(Student o1, Student o2) {
        // 名字是字符串，不能直接加减，要用 compareTo 方法比较
        return o1.name.compareTo(o2.name);
    }
}

public class demo1 {
    public static void main(String[] args) {
        Student[] students = new Student[]{
                new Student("张三",23),
                new Student("王五", 97),
                new Student("李四", 96),
                new Student("赵六", 92),
        };
        System.out.println(Arrays.toString(students));

        // 按名字比较
        // 先创建一个比较器 nc
        NameComparator nc = new NameComparator();
        // 在 sort 方法中使用比较器
        Arrays.sort(students,nc);
        System.out.println(Arrays.toString(students));

        // 按年龄比较
        AgeComparator ac = new AgeComparator();
        Arrays.sort(students,ac);
        System.out.println(Arrays.toString(students));
    }
}

自定义类型的比较一定要实现可比较接口才可以进行排序

⛅两种比较方法的区别：

Comparable: 对类的侵入性强，一旦写好，不能轻易改动。
Comparator : 更加灵活，对类的侵入性弱，更推荐使用。

2.7.3 Clonable 接口和深拷贝

Java 中内置了一些很有用的接口, Clonable 就是其中之一.Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 “拷贝”. 但是要想合法调用 clone 方法, 必须要先实现 Clonable 接口。

Clonable 接口为什么是一个空接口？有什么作用？
空接口又叫做标志接口，表示实现它的类是可以被 clone 的。

class Animal implements Cloneable{
    private String name;

    public Animal(String name){
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        // 返回的是 Object 类型
        return super.clone();
    }
}

public class demo1 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Animal a1 = new Animal("123");
        // 返回的是 Object 类型，要进行强制类型转换
        Animal a2 = (Animal) a1.clone();
        System.out.println(a2.getName());
    }
}

// 输出 ： 123

浅拷贝和深拷贝

class Money {
    public int m;
}

// 实现 Clonable 接口

class Person implements Cloneable {
    public int age;
    Money money = new Money();

    @Override
    public String toString() {
        return "Person{" +
                ", age=" + age +
                '}';
    }

    // 虽然Cloneable是一个空接口，但是必须在类中重写 clone 方法
    //throws CloneNotSupportedException 抛出异常

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class t1 {
    public static void main(String[] args) throws CloneNotSupportedException {

        // 这样的写法不能 clone 引用变量，是浅拷贝。更改拷贝值时会影响原型

        Person p1 = new Person();
        p1.money.m = 12;
        Person p2 = (Person) p1.clone();
        System.out.println(p1.money.m);
        System.out.println(p2.money.m);
        System.out.println("---------------------------------------");
        p2.money.m = 9955;
        System.out.println(p1.money.m);
        System.out.println(p2.money.m);
    }
}
/*	输出：
*	12  12
*	9955 9955
*/

如上代码，我们可以看到，通过 Clone ，只是拷贝了 Person 对象，但是 Person 中的 Money 对象，并没有被拷贝。通过 person2 这个引用修改了 m 的值后， person1 中的值也发生了改变。这就是发生了浅拷贝。那么如何才能实现深拷贝呢？

// 让 money 类也可以被被克隆
class Money implements Cloneable{
    public int m;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

// 实现 Clonable 接口
class Person implements Cloneable{
    int age;
    Money money = new Money();

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person tmp = (Person) super.clone();
        // 拷贝 money 的引用
        tmp.money = (Money) this.money.clone();
        return tmp;
    }
}

public class t2 {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person p1 = new Person();
        p1.money.m = 12;
        Person p2 = (Person) p1.clone();
        System.out.println(p1.money.m);
        System.out.println(p2.money.m);
        System.out.println("---------------------------------------");
        p2.money.m = 9999;
        System.out.println(p1.money.m);
        System.out.println(p2.money.m);
    }
}

/*	12
*	12
*	---------------------------------------
*	12
*	9999
*/

⛅ 上面的代码便是深拷贝的写法，深拷贝和浅拷贝，不在于方法，而在于具体代码的实现。

🌟 2.8 抽象类和接口的区别

抽象类和接口都是 Java 中多态的常见使用方式。需要在重点掌握的同时认清两者的区别（***）。
🔥

核心区别：
抽象类中可以包含普通方法和普通字段，这样的普通方法和字段可以被子类直接使用，不必重写，而接口中不能包含普通方法，子类必须重写所有抽象方法。

public Animal{
	protected String name;
	
	public Animal(String name){
		this.name = name;
	}
}

// 这里的 Animal 只能作为抽象类，不能作为接口

抽象类的存在是为了让编译器更好的校验，Animal 这样的类一般不会直接使用，而是使用它的子类。

🚀 三、 Object 类

Object 类是 Java 默认提供的一个类。Java 中除了 Object 类，所有的类都是存在继承关系的，默认会继承 Object 类。
所有类的对象都可以使用 Object 类的引用进行接收。

class Person{}
class Student{}

public class Test {
	public static void main(String[] args) {
	function(new Person());
	function(new Student());
}

// Object 类的引用可以接受任何类的对象
public static void function(Object obj) {
	System.out.println(obj);
	}
} 

// 执行结果：
// Person@1b6d3586
// Student@4554617c

Object 类也有一些自己的方法：
在这里插入图片描述
下面来熟悉几个方法：

🌟 3.2 获取对象信息

如果要打印对象中的内容，可以直接重写 Object 类中的 toString() 方法。

// Object类中的toString()方法实现：

public String toString() {
	return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

🌟 3.3 对象比较 equals 方法

在Java中， == 进行比较时：
a.如果 == 左右两侧是基本类型变量，比较的是变量值是否相同。
b.如果 == 左右两侧是引用类型变量，比较的是引用变量地址是否相同。
c.如果要比较对象中内容，必须重写 Object 中的 equals 方法，因为 equals 方法默认也是按照地址比较的：

// Object类中的equals方法
public boolean equals(Object obj) {
	return (this == obj); // 使用引用中的地址直接来进行比较
}

class Person{
	private String name ;
	private int age ;
	
	public Person(String name, int age) {
	this.age = age ;
	this.name = name ;
	}
}
public class Test {
	public static void main(String[] args) {
	Person p1 = new Person("zhangsan", 20) ;
	Person p2 = new Person("zhangsan", 20) ;
	int a = 10;
	int b = 10;
	System.out.println(a == b); 		// 输出true
	System.out.println(p1 == p2); 		// 输出false
	System.out.println(p1.equals(p2)); 	// 输出false
	}
}

Student 类重写 equals() 方法，然后比较：

class Person{
...
@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.4 hashcode 方法

hashcode 方法可以用来比较两个对象在内存中存储的位置是否相同。

我们认为两个相同的对象，应该存储在同一个位置，如果不重写 hashcode() 方法：

class Person{
    public String name;
    public int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

}

public class demo1 {
    public static void main(String[] args) {
        Person p1 = new Person("zhangsan",18);
        Person p2 = new Person("zhangsan",18);
        System.out.println(p1.hashCode());
        System.out.println(p2.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 demo1 {
    public static void main(String[] args) {
        Person p1 = new Person("adcz",18);
        Person p2 = new Person("adcz",18);
        System.out.println(p1.hashCode());
        System.out.println(p2.hashCode());
    }
}

// 92660537
// 92660537

hash 值一样。

🌕总结：

hashcode() 方法用来确定对象在内存中存储的位置是否相同。

江初。

关注

5
点赞
踩
3

收藏

觉得还不错? 一键收藏
2
评论
六、抽象类和接口

文章目录🚀 一、抽象类🌟 1.1 抽象类的概念🌟 1.2 抽象类语法🌟 1.3 抽象类特性🚀 一、抽象类🌟 1.1 抽象类的概念在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。🌟 1.2 抽象类语法在Java中，一个类如果被 abstract 修饰称为抽象类，抽象类中被 abstract 修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。// 抽象类：被 abstract
复制链接

扫一扫