4.2学习总结

一.java学习总结

(本次java学习总结,主要总结了抽象类和接口的一些知识,和它们之间的联系和区别)

一.抽象类

1.1定义:

抽象类主要用来抽取子类的通用特性，作为子类的模板，它不能被实例化，只能被用作为子类的超类。

2.概括:

有方法声明，没有方法体”的一类方法统称为抽象方法，抽象方法用关键字abstract修饰。需要注意的是，如果一个方法已经确定是抽象方法，那么它绝不能再有方法体，即不能出现大括号，而是只需要在()后面添加一个分号即可

3.注意点:拥有抽象方法的类一定是抽象类；但是抽象类不一定有抽象方法。

1.2使用场景

当父类需要定义一个方法，却不能明确该方法的具体实现细节时，可以将该方法定义为abstract，具体实现细节延迟到子类。(让子类重写这个方法）

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

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

    //如果不知道在这个方法中应该写什么，可以通过抽象方法的形式,让子类进行重写
    public abstract void eat();
}

(若父类中定义了一个抽象方法，要求其所有非抽象子类都必须重写该抽象方法。否则会报错)

1.3抽象类的特点

1.abstract关键字 :

abstract关键字只能用于修饰类和方法，用于声明抽象类和抽象方法。

格式:

修饰符 abstract class 类名()

修饰符 abstract 返回值类型方法名(形参例表)

2.抽象类不能被实例化，只能创建其子类对象.

3. 如果某个类继承了一个抽象类，那么这个类有两个选择——要么实现父类所有的抽象方法，要么子类本身也定义成抽象类。

4.事例

Animal(父类)

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

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

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void drink(){
        System.out.println("喝水");
    }

    //如果不知道在这个方法中应该写什么，可以通过抽象方法的形式,让子类进行重写
    public abstract void eat();
}

子类

//子类Cat
public class Cat extends Animal{
    @Override
    public void eat() {
        System.out.println("猫在吃鱼");
    }
}

//子类Dog
public class Dog extends Animal{

    @Override
    public void eat() {
        System.out.println("狗在吃骨头");
    }
}

//子类Sleep
public class Sleep extends Animal{
    @Override
    public void eat() {
        System.out.println("山羊在吃草");
    }
}

测试

import jdk.nashorn.internal.ir.CatchNode;

public class TEXT {
    public static void main(String[] args) {
        Dog d=new Dog();
        d.setName("小狗");
        d.setAge(1);
        System.out.println(d.getName()+", "+d.getAge());
        d.eat();
        d.drink();

        Cat c =new Cat();
        c.setName("小猫");
        c.setAge(2);
        System.out.println(c.getName()+", "+c.getAge());
        c.eat();
        c.drink();

        Sleep s=new Sleep();
        s.setName("山羊");
        s.setAge(3);
        System.out.println(s.getName()+", "+s.getAge());
        s.eat();
        s.drink();
    }
}

运行结果

总结:抽象类中我们主要学习其抽象方法的使用, (抽象类中的成员只比非抽象类多一种——抽象方法。其他都和非抽象类一样)

二.接口

2.1定义:

Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。

简单来说:接口就是一种被规范的标准，只要符合这个标准都可以通用，接口的表现在于对行为的抽象.

格式:

定义接口:interface 接口名{ }

使用接口:class 类名 implements 接口名{ }

2.2接口的特点:

1.接口中的成员变量

接口中没有成员变量,只要共有静态常量(即默认情况下都有 public static final 这三个关键字修饰)
格式:public static final 常量名=常量值
在接口中定义公有静态常量时，必须在定义时就赋初值。

public interface swim {
    //初始化要赋值
    public static final int num=1;
    
    public abstract void Swim();
}

2.接口中的成员方法

3.接口中的创建对象

接口不能被实例化.
接口的子类可以是抽象实现类,也可以是非抽象的(非抽象实现类要重写接口中的所有抽象方法)

4.接口的继承关系

类与接口之间的关系:多实现(一个类可以实现多个接口,弥补java无法多继承)
接口与接口之间的关系:一个接口可以多继承多个接口(接口 extends 接口1，接口2，接口3...)
继承和实现的区别:继承是父类中的共性内容,实现是父类中的特性(扩展)内容.

2.3实例:

Animal和前面的相同(不展示了)

接口

public interface swim {
    //初始化要赋值
    public static final int num=1;

    public abstract void Swim();
}

子类

//子类Dog
public class Dog extends Animal implements swim{

    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗在吃骨头!");
    }

    @Override
    public void Swim() {
        System.out.println("狗在狗刨!");
    }
}

//子类Flag
public class Flag extends Animal implements swim{

    public Flag() {
    }

    public Flag(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("青蛙再吃虫子!");
    }

    @Override
    public void Swim() {
        System.out.println("青蛙在蛙泳!");
    }
}

//子类rabbit
public class rabbit extends Animal{

    public rabbit() {
    }

    public rabbit(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("兔子在吃草!");
    }

    public void jump(){
        System.out.println("兔子在蹦高!");
    }
}

text

public class Text {
    public static void main(String[] args) {
        Dog d=new Dog("狗剩子",1);
        System.out.println(d.getName()+", "+d.getAge());
        d.eat();
        d.Swim();
        System.out.println("--------------------");

        rabbit r=new rabbit("麻辣兔头",1);
        System.out.println(r.getName()+", "+r.getAge());
        r.eat();
        r.jump();
        System.out.println("--------------------");

        Flag f=new Flag("青蛙王子",2);
        System.out.println(f.getName()+", "+f.getAge());
        f.eat();
        f.Swim();
        System.out.println("--------------------");
    }
}

运行结果: