做网站用笔记本做服务器吗整站seo优化一般多少钱

1.抽象类

1.1 概念

在之前讲Java SE(6)——类和对象（一）的时候说过，所有的对象都可以通过类来抽象。但是反过来，并不是说所有的类都是用来抽象一个具体的对象。如果一个类本身没有足够的信息来描述一个具体的对象，而是用于定义一个模板，为子类提供通用的属性和方法，这样的类就是抽象类

1.2 语法规则

在Java中，被abstract修饰的类就是抽象类；被abstract修饰的方法就是抽象方法

//抽象类
public abstract class AbstractClass {//抽象方法public abstract void abstractMethod();
}

• 1.抽象类不能直接实例化，它只能作为其他类的父类

• 2.抽象方法是一种没有具体实现的方法，即没有方法体

• 3.抽象类中也可以定义普通成员变量/普通成员方法/构造方法。换言之，抽象类中不一定有抽象方法，但是抽象方法所在的类一定是抽象类
  
  

• 4.abstract只能修饰类和方法，没有抽象变量这个概念

• 5.抽象方法不能用private/static/final修饰

问题：既然抽象类无法直接实例化对象，那么抽象类真正的作用是什么？
在上面讲概念和语法规则的时候说过，抽象类只能作为父类被其他类继承，给子类提供一个模板并由子类来实现。

1.3 抽象类的实现

public abstract class Shape {//普通成员变量public int width;public int length;//普通方法public void hello(){System.out.println("hello shape");}//构造方法public Shape(int width, int length) {this.width = width;this.length = length;}public abstract void draw();
}
public class Circle extends Shape {public Circle(int width, int length) {super(width, length);}@Overridepublic void draw() {System.out.println("draw circle:" + this.width + " * " + this.length);}@Overridepublic void hello(){System.out.println("hello circle");}
}
public class Test {public static void main(String[] args) {//无法直接实例化抽象类/*Shape shape = new Shape();*/Shape circle = new Circle(10,10);circle.draw();circle.hello();}
}

运行结果：
draw circle:10 * 10
hello circle

• 1.当某一个类（称为实现类）继承抽象类时，该实现类必须重写抽象类中的所有抽象方法 （这也是抽象方法不能使用private/static/final修饰的根本原因）

• 2.如果是抽象类A继承抽象类B，则暂不需要重写父类中的抽象方法。直到有实现类C来继承抽象类A，那么实现类C要重写A和B中的所有抽象方法

1.4 意义

仔细观察上述代码，抽象类和实现类之间构建了继承关系，发生了向上转型/方法重写。但是普通类和普通类之间好像也可以完成上述操作，换言之，抽象类能完成的功能普通类也可以。那么抽象类存在的意义是什么？
还是以上述代码为例，此时的需求是画一个circle。假设父类使用普通类，如果用户一不小心将父类直接实例化，那么此时调用draw()方法就无法画一个circle出来；再假设父类使用抽象类，如果用户直接实例化父类是会报错的，而且子类如果不重写抽象方法也是会报错的，这就是抽象类在提醒用户。使用抽象类相较于使用普通类，在特定场景下多了一层校验效果

2.接口

2.1 概念

在日常生活中，经常听到接口这个东西。比如：电脑的USB-A接口，既可以连接键盘，又可以连接鼠标、耳机等等，只要是适配UEB协议的设备都可以连接

通过这些例子可以简述一下接口的作用：接口就是公共的行为规范标准。在实现某些功能时只要符合该规范标准就行了
在Java中，接口可以看作是多个类的公共规范，是一种引用数据类型

2.2 语法规则

定义接口需要借助interface关键字

public interface 接口名称{
}

• 1.接口中的方法默认使用public abstract修饰，所以定义方法时，建议不要再手动添加修饰词
  

• 2.接口中的变量默认使用public static final修饰

• 3.接口中不能定义构造方法

• 4.在JDK8及以后，接口中可以定义静态方法和default方法
  default方法时接口中独有的方法，等会儿仔细说说default方法的作用

2.3 接口的实现

接口和抽象类一样，也不能直接实例化对象，只能由某个具体的类来实现。并且在Java SE(8)——继承中讲过，一个类只能拥有一个父类，但是一个类可以实现多个接口

类实现接口使用的是implements关键字

2.3.1 实现单接口

需求：实现电脑使用Usb设备（鼠标、键盘）

• IUsb接口：包含打开设备、关闭设备的功能
• Mouse类：实现IUsb接口，并具备点击功能
• KeyBoard类：实现IUsb接口，并具备输入功能
• Computer类：包含开机功能、关机功能和使用IUsb设备功能

//IUsb接口
public interface IUsb {void openDevice();void closeDevice();
}
//Mouse类实现IUsb接口
public class Mouse implements IUsb {@Overridepublic void openDevice() {System.out.println("Mouse open");}@Overridepublic void closeDevice() {System.out.println("Mouse close");}public void click(){System.out.println("Mouse click");}
}
//KeyBoard类实现IUsb接口
public class KeyBoard implements IUsb {@Overridepublic void openDevice() {System.out.println("KeyBoard open");}@Overridepublic void closeDevice() {System.out.println("KeyBoard close");}public void input(){System.out.println("KeyBoard input");}
}
//电脑类，使用Use设备(鼠标、键盘)
public class Computer {public void open(){System.out.println("Computer open");}public void useUsb(IUsb iusb){iusb.openDevice();if (iusb instanceof KeyBoard){//向下转型KeyBoard keyBoard = (KeyBoard)iusb;keyBoard.input();}if (iusb instanceof Mouse){//向下转型Mouse mouse = (Mouse)iusb;mouse.click();}iusb.closeDevice();}public void close(){System.out.println("Computer close");}
}
//测试类
public class Test {public static void main(String[] args) {Computer computer = new Computer();computer.open();computer.useUsb(new Mouse());computer.useUsb(new KeyBoard());computer.close();}
}

运行结果：
Computer open
Mouse open
Mouse click
Mouse close
KeyBoard open
KeyBoard input
KeyBoard close
Computer close

2.3.2 实现多接口

public interface IRunning {void run();
}
public interface ISwimming {void swim();
}
public class Animal {public String name;public Animal(String name){this.name = name;}
}
//青蛙既能跑又能游
public class Frog extends Animal implements IRunning,ISwimming{public Frog(String name) {super(name);}@Overridepublic void run() {System.out.println(this.name + " is running");}@Overridepublic void swim() {System.out.println(this.name + " is swimming");}public void act(){this.run();this.swim();}
}
public class Test {public static void main(String[] args) {Frog frog = new Frog("Frog");frog.act();}
}

运行结果：
Frog is running
Frog is swimming

2.4 接口的继承

在Java中，类和类之间是单继承的，⼀个类可以实现多个接口，接口与接口之间可以多继承。

即：用接口可以达到多继承的目的

public interface IRunning {void run();
}
public interface ISwimming {void swim();
}
//Act接口继承IRunning和ISwimming接口
public interface Act extends IRunning,ISwimming{@Overridevoid run();@Overridevoid swim();
}
public class Animal {public String name;public Animal(String name){this.name = name;}
}
//青蛙既能跑又能游
public class Frog extends Animal implements Act{public Frog(String name) {super(name);}@Overridepublic void run() {System.out.println(this.name + " is running");}@Overridepublic void swim() {System.out.println(this.name + " is swimming");}public void act(){this.run();this.swim();}
}
public class Test {public static void main(String[] args) {Frog frog = new Frog("Frog");frog.act();}
}

运行结果不变

2.5 default方法的作用

• 默认实现：允许拥有具体的实现。实现类可以选择是否重写该方法

• 多重继承的解决方法：当某个具体类实现了非常多的接口时，接口之间可能会存在同名的方法。通过default方法可以解决同名方法的冲突 ```java public interface IA {
  default void func(){
  System.out.println(“IA func”);
  } } public interface IB {
  default void func(){
  System.out.println(“IB func”);
  } } public class Demo implements IA,IB {
  @Override
  public void func() {
  //调用IA中的默认方法
  IB.super.func();
  } } public class Test {
  public static void main(String[] args) {
  Demo demo = new Demo();
  demo.func();
  } } ````在上述代码中必须在Demo类中重写func()方法才能解决同名冲突问题，所谓的重写就是选择调用IA还是IB中的default方法，并没有改变方法的原有实现。`如果IA和IB中是public
  abstract修饰的方法，没有具体实现，只能由Demo类来实现，那么必然有一个接口中的func()方法无法被重写

• 向后兼容性：default方法使得在现有的接口中添加新方法成为可能，而不会破坏已有的实现类。如果没有default方法，添加新方法到接口会导致所有实现类都需要实现这个新方法，这会破坏向后兼容性

2.5 接口和抽象类的区别

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

如之前写的 Animal 例子。此处的Animal中包含⼀个name这样的属性，这个属性在任何子类中都是存在的。因此下面的Animal只能作为⼀个抽象类，而不应该成为一个接口

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