抽象类与接口
一、抽象类
1.抽象类的介绍
I 代码展示
public class 抽象类 {
public static void main(String[] args) {
Chinese chinese = new Chinese();
chinese.country();
chinese.nation();
}
}
abstract class Human{//关键字 abstract 修饰，抽象类
public void speak(String s){
System.out.println();
}
//抽象类中不一定有抽象方法，但抽象方法一定在抽象类中；
abstract void country();//抽象方法，功能由其子类进行实现
abstract void nation();
}
//一个具体的实现类 Chinese
class Chinese extends Human{
@Override//覆盖抽象方法并重写
void country() {
this.speak("我是一个中国人。");//通过覆盖重写实现具体的功能
}
@Override
void nation() {
this.speak("我是汉族人。");
}
}
II 总结
- 有abstract关键字修饰；
- 必须由其子类创建对象，抽象类不能被实例化；
- 抽象类实体中可以有abstract方法，该方法只能声明不可实现；
- 抽象类中不一定有抽象方法，但抽象方法一定在抽象类中；
- 抽象类的子类必须重写abstract方法；
- 抽象类只关心它的子类是否具有某种功能，并不关心功能的具体实现；
- 功能的具体行为由子类负责实现。
2.抽象类的应用
I 代码展示
abstract class Shape{//声明表示形状的抽象类Shape
abstract void draw();
abstract void erase();
}
class Circle extends Shape {//声明表示圆形的子类
@Override
void draw() {
System.out.println("Circle.draw()");
}
@Override
void erase() {
System.out.println("Circle.erase()");
}
}
class Square extends Shape {
@Override
void draw() {
System.out.println("Square.draw()");
}
@Override
void erase() {
System.out.println("Square.erase()");
}
}
class Triange extends Shape {//声明表示三角形的子类
@Override
void draw() {
System.out.println("Triange.erase()");
}
@Override
void erase() {
System.out.println("Triange.erase()");
}
}
public class 抽象类的应用 {
public static Shape randShape() {
switch ((int) (Math.random() * 3)) {
default:
case 0:
return new Circle();
case 1:
return new Square();
case 2:
return new Triange();
}
}
public static void main(String[] args) {
Shape[] s = new Shape[9];
for (int i = 0; i < s.length; i++) {
s[i] = randShape();
s[i].draw();
}
}
}
II 总结
- 继承层越高，类就越通用，并且越抽象
- 抽象：本质上相同的具体概念的抽象
二、接口
1.接口的声明与接口体
I 代码实现
public class 接口 {
public static void main(String[] args) {
//可以声明一个接口的引用变量，那么所有实现此接口的类的对象引用都可以赋给此引用变量
A a;
a = new D();
a.aaa();
int s = a.num;
}
}
class D implements A, B{
@Override
public void aaa() {
//包含接口的类，要实现该接口的方法
}
}
abstract class E implements A{
//没有完全实现接口的方法，该类必须是abstract类型
}
interface A {
final int num = 0;//接口的变量一般为 final或static 类型，必须以常量值来初始化
static int count = 0;
void aaa();//没有方法体，本质上还是抽象方法
}
interface B{
}
interface C extends A{//通过关键字 extends 继承其他接口
}
II 接口的声明与接口体
- (public) interface + name ;
- 接口中的方法没有方法体，虽然没有abstract修饰，但本质上都是抽象的方法
- 接口中指定的方法没有默认的实现，每个包含接口的类必须实现所有方法
- 接口的变量一般为 final或static 类型，必须以常量值来初始化
- 如果接口本身定义为public类型，则接口中所有的方法和变量均为public
- (public) class classname implements interfacename
- 类中实现接口的方法必须声明成public，而且实现方法的类型必须跟接口定义中的类型一致
- 一个类包含一个接口但不完全实现接口定义的方法，那么该类一定是抽象类
- 接口可以通过关键字 extends 继承其他接口
- 可以声明一个接口的引用变量，那么所有实现此接口的类的对象引用都可以赋给此引用变量
2.理解接口
- 接口只关心功能，而不关心功能的具体实现
- 接口与抽象类的重要区别：接口是用来定义操作和行为的，而抽象类是用来定义实体的
三、接口的应用
1.接口回调
I 代码展示
//接口的回调
interface ShowMessage{
void showMessage();
}
class TV implements ShowMessage{
@Override
public void showMessage() {
System.out.println("This is a TV");
}
}
class Computer implements ShowMessage{
@Override
public void showMessage() {
System.out.println("This is a Computer");
}
}
public class 接口的应用1 {
public static void main(String[] args) {
ShowMessage sm;//声明接口变量
sm = new TV();//接口变量中存放对象的引用
sm.showMessage();//接口回调
sm = new Computer();//接口变量中存放对象的引用
sm.showMessage();//接口回调
}
}
II 总结
接口回调是多态的另一种实现，指：可以使用某一接口的类创建的对象的引用赋值给该接口声明的接口的变量，则该接口变量就可以调用被雷实现的接口中的方法。当接口变量调用被类实现的接口中的方法时，就是通知相应的对象调用接口的方法
2.接口作为参数
I 代码展示
//接口作为参数
interface Speak {
void speak();
}
class UserOne implements Speak {
@Override
public void speak() {
System.out.println("hello");
}
}
class UserTwo implements Speak {
@Override
public void speak() {
System.out.println("hi");
}
}
class Listener {
public void listen(Speak s){//方法的参数为接口类型
s.speak();
}
}
public class 接口的应用2 {
public static void main(String[] args) {
Listener listener = new Listener();
listener.listen(new UserOne());
listener.listen(new UserTwo());
}
}
II 总结
- 当一个方法的参数是一个接口类型时（如果一个类实现了该接口），就可以把该类的实例引用传值给该参数，参数就可以回调类实现的方法
- 使用接口还可以实现对调用方法的权限限制
学习从点滴开始，学到的东西可能会忘记，记得点赞收藏哦
System.out.println("我选择滑稽取宠");