JavaSE学习之--抽象类,接口,内部类（二）-阿里云开发者社区

JavaSE学习之--抽象类,接口,内部类（一）+https://developer.aliyun.com/article/1413496

8.在jdk8中：接口还可以包含default方法

我们知道接口中的方法都是抽象方法，不含有主体，但在jdk8中引入了一个新特性-->default关键字，在接口中，如果方法被default修饰，则此方法可以含有主体，且在类中不必须被重写（相当于自动继承了）

interface IUSB {
    void method1();
    default void method2() {
        System.out.println("This is a default method!");
    }
}
class Mouse implements IUSB {
    @Override
    public void method1() {
        System.out.println("hehe");
    }
    // method2不重写也不会报错
    // 相当于“自动继承”
}
public class Test1 {
    public static void main(String[] args) {
        Mouse mouse = new Mouse();
        mouse.method1();
        // 没有重写method2，也能调用该方法，证明该方法被“自动继承”了
        mouse.method2();
    }
}

4.实现多接口

Java中类是单继承的，一个类无法继承多个类（不能有多个父亲），但可以同时实现多个接口！

通过implements+','实现多个接口！！！

下面通过类来表示一组动物

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

另外提供一些接口，分别表示 "会飞的", "会跑的", "会游泳的".

interface IFlying {
    void fly();
}
interface ISwimming {
    void swim();
}
interface IRunning {
    void run();
}

猫类：跑

// 猫类
class Cat extends Animal implements IRunning {
    public Cat(String name) {
        super(name);
    }
    // ctrl+i快速调出接口抽象方法的重写
    @Override
    public void run() {
        System.out.println(this.name + "猫正在跑步");
    }
}

狗类：跑，游

// 狗类 跑+游
class Dog extends Animal implements IRunning,ISwimming {
    public Dog(String name) {
        super(name);
    }
    @Override
    public void swim() {
        System.out.println(this.name + "正在狗刨");
    }
    @Override
    public void run() {
        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 swim() {
        System.out.println(this.name + "鸭子正在游泳");
    }
    @Override
    public void run() {
        System.out.println(this.name + "鸭子正在跑步");
    }
}

注意：一个类实现多个接口时，所有接口中的抽象方法都要被重写！！！

public class Test1 {
    public static void main(String[] args) {
        Dog dog = new Dog("mimi");
        dog.run();
        dog.swim();
        System.out.println("================");
        Cat cat = new Cat("jiji");
        cat.run();
        System.out.println("================");
        Duck duck = new Duck("hehe");
        duck.fly();
        duck.run();
        duck.swim();
    }
}

上面代码展示了Java面向对象编程中最常见的用法：一个类继承一个父类，同时实现多个接口！！

可以理解为接口时“部分共性”，但本质还是为了代码复用

继承表达式是is-a语义，接口表达的含义是“具有xxx特性”

猫是一种动物, 具有会跑的特性.

狗也是一种动物, 既能跑, 也能游泳

鸭子也是一种动物, 既能跑, 也能游, 还能飞

这样做的好处是可以让程序员忘记类型，只关注实现特性，关注某个类是否具有该特性

比如我们可以创建一个Robot类，他也可以实现IRunning接口，尽管他不是Animal类！

class Robot implements IRunning {
    @Override
    public void run() {
        System.out.println("the robot is running!");
    }
}

创建一个方法调用接口中的方法（接口作为参数）

public class Test1 {
    // 接口和类一样，可以作为参数类型，当对象传递时发生动态绑定
    // 谁实现了接口，谁就可以调用接口方法
    public static void Run(IRunning running) {
        running.run();
    }
    public static void main(String[] args) {
        // 匿名对象的直接调用
        Run(new Cat("jiji"));
        Run(new Dog("mimi"));
        Run(new Duck("hehe"));
        Run(new Robot());
    }

5.接口之间的继承

接口之间也存在继承关系，不同于类的是，一个接口可以继承多个接口

interface IRunning {
    void run();
}
interface ISwimming {
    void swim();
}
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
}
class Frog implements IAmphibious {
...
}

通过接口继承创建一个新的接口 IAmphibious 表示 "两栖的". 此时实现接口创建的 Frog 类, 就继续要实现 run 方法, 也需要实现 swim 方法，同时继承两个接口！！！

6.抽象类和接口的区别：

1.成员变量：抽象类中可以含有普通成员变量，接口中的成员变量都是被public static final修饰的

2.方法：抽象类中既可以有抽象方法也可以有普通方法，而接口中所有的方法都是public abstract修饰

3.继承关系：一个类只能继承一个父类，但可以实现多个接口。但接口与接口之间只有继承关系

三. Object类

Object类是Java中默认提供的一个类，他是所有类的父类，是类的“祖先”。为什么会有这么一个类呢？其实也很好理解，Java是一个面向对象编程的语言，它存在很多自定义的类，那程序员是如何写出这些自定义的类呢？本质上还是通过Object这个祖先类来开发的！！！

1.Object可以接受任意类型的对象

class Person{};
class Stu{};
public class Test1 {
    // 此处发生了向上转型
    public static void func(Object object) {
        System.out.println(object);
    }
    public static void main(String[] args) {
        func(new Person());
        func(new Stu());
    }
}

2.Object本质上还是Java中的一个类，含有一些自带的方法

本文主要讲解equals,hashcode,toString方法

1.toString方法--获取对象信息

前面我们已经重写了很多toString方法，当时可能很不理解为什么toString方法要重写呢？他是来源于哪个类呢？现在可以解释这个问题了，toString方法是Object类自带的一个方法，所有的类都是Object的子类，所以要重写toString方法来实现我想获取的信息

toString的源码

2.equals方法--进行对象比较

在Java中，==比较时

如果左右两侧是基本数据类型（int等等），直接比较值的大小即可

如果左右两侧是引用数据类型（比如对象），实际上比较的是引用类型的地址是否相同

如果想比较对象中的内容，就要重写equals方法

equals的源码：

public static void main(String[] args) {
        Person person1 = new Person();
        Person person2 = new Person();
        // 当两个引用类型比较时，实际上比较的是地址
        System.out.println(10 == 20);// false
        System.out.println(person1 == person2);// false
        System.out.println(person1.equals(person2));// false
        System.out.println("=======================");
        person2 = person1;
        System.out.println(person1.equals(person2));// true
    }

两个对象的比较是判断对象的地址是否相同，也即是在内存中存储的位置是否相同

Person person1 = new Person("lisi",18);
        Person person2 = new Person("lisi",18);
        System.out.println(person1.toString());
        System.out.println(person2.toString());

可以看出，两个对象的地址不同

重写equals方法：

假如我想使用Person类中的age来判断两个对象是否相同，此时就要重写equals方法

class Person{
    int age;
    public Person(int age) {
        this.age = age;
    }
    @Override
    public boolean equals(Object object) {
        // 两个对象地址相同，直接返回true
        if (this == object) return true;
        // 比较的对象是null或两个对象的类型不同，直接返回false
        if (object == null || getClass() != object.getClass()) return false;
        // 此处进行向下转型
        Person person = (Person) object;
        return age == person.age;
    }
    @Override
    public int hashCode() {
        return Objects.hash(age);
    }
}
public class Test1 {
    public static void main(String[] args) {
        Person person1 = new Person(10);
        Person person2 = new Person(20);
        Person person3 = new Person(20);
        System.out.println(person1.equals(person2));// false
        System.out.println(person2.equals(person3));// true
    }

注意：可以通过快捷键快速生成toString和hashcode的重写方法

结论：通过对象中的内容进行比较时，一定要重写toString方法！

JavaSE学习之--抽象类,接口,内部类（三）+https://developer.aliyun.com/article/1413501

JavaSE学习之--抽象类,接口,内部类（二）

8.在jdk8中：接口还可以包含default方法

4.实现多接口

5.接口之间的继承

6.抽象类和接口的区别：

三. Object类

1.Object可以接受任意类型的对象

2.Object本质上还是Java中的一个类，含有一些自带的方法

1.toString方法--获取对象信息

toString的源码

2.equals方法--进行对象比较

equals的源码：

重写equals方法：

热门文章

最新文章

相关电子书

相关实验场景

JavaSE学习之--抽象类,接口,内部类（二）

8.在jdk8中：接口还可以包含default方法

4.实现多接口

5.接口之间的继承

6.抽象类和接口的区别：

三. Object类

1.Object可以接受任意类型的对象

2.Object本质上还是Java中的一个类，含有一些自带的方法

1.toString方法--获取对象信息

toString的源码

2.equals方法--进行对象比较

equals的源码：

重写equals方法 ：

热门文章

最新文章

相关电子书

相关实验场景

重写equals方法：