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{@Overridepublic void eat() {System.out.println("猫在吃鱼");}
}//子类Dog
public class Dog extends Animal{@Overridepublic void eat() {System.out.println("狗在吃骨头");}
}//子类Sleep
public class Sleep extends Animal{@Overridepublic 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);}@Overridepublic void eat() {System.out.println("狗在吃骨头!");}@Overridepublic void Swim() {System.out.println("狗在狗刨!");}
}//子类Flag
public class Flag extends Animal implements swim{public Flag() {}public Flag(String name, int age) {super(name, age);}@Overridepublic void eat() {System.out.println("青蛙再吃虫子!");}@Overridepublic void Swim() {System.out.println("青蛙在蛙泳!");}
}//子类rabbit
public class rabbit extends Animal{public rabbit() {}public rabbit(String name, int age) {super(name, age);}@Overridepublic 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("--------------------");}
}

运行结果: