一. 抽象类
======
1.1 抽象类的概念
在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，如果一个类没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。例如：
说明：
1.Animal类是动物类，每个动物都有叫的方法，但是Animal不是一个具体的动物，因此其内部的bark()方法无法具体实现。
2.Dog是狗类继承Animal类，狗是一个具体的动物，狗叫“旺旺”，其bark()可以实现。
3.Cat是猫类继承Animal类，猫是一个具体的动物，猫叫“喵喵”，其bark()可以实现。
4.因此Animal可以设计为“抽象类”。
没有实际的工作方法，我们可以把它设计为抽象方法，包含抽象方法的类称为“抽象类”。
1.2 抽象类的语法
在Java中一个类被 abstract 修饰称为抽象类，抽象类中被abstract修饰的方法被称为抽象方法，抽象方法不用给出具体的实现体。
public abstract class Animal { //抽象类，被abstract修饰
abstract void eat(); //抽象方法，被abstract修饰没有方法体
abstract void sleep();
public void run(){ //也可以增加普通方法和属性
System.out.println(“跑”);
}
}
**注意：**抽象类也是类，内部可以包含普通方法和属性和构造方法
1.3 抽象类特性
1.抽象类不能直接实例化对象
Animal animal = new Animal();
//编译报错，因为Animal是抽象的无法实例化
2.抽象方法不能被private修饰
abstract private void eat();
//编译报错，非法的修饰符组合：abstract和private
注意：抽象方法没有加访问访问修饰符，默认是public.
3.抽象方法不能被final和static修饰，因为抽象方法要被子类重写
abstract final void eat();
abstract static void sleep();
//编译报错，非法的修饰符组合
4.抽象类必须被继承，并且被继承后子类要重写父类中所有的抽象方法，否则子类也是抽象类，必须要用abstract修饰
public abstract class Animal {
abstract void eat();
abstract void sleep();
}
public class Dog extends Animal {
@Override
void eat() {
}
@Override
void sleep() {
}
}
public abstract class Cat extends Animal{
@Override
void eat() {
}
}
5. 抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类
6. 抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量
1.4 抽象类的作用
抽象类本身不能被实例化，要想使用只能创建该抽象类的子类，然后让那个子类重写父类中的抽象方法。
使用抽象类，实际工作不由父类完成，而应由子类完成，如果此时不小心误用父类了，使用普通类编译器不会报错，但是父类是抽象类就会在实例化的时候提示错误，让我们尽早发现问题。
二. 接口
=====
2.1 接口的概念
现实生活中接口的例子很多，比如电脑上的USB接口，电源插座等。
电脑的USB口可以插：U盘，鼠标键盘，所有符合USB协议的设备
电源的插座可以插：电脑，电视机，电饭煲，所有符合规范的设备
上述例子可以看出：接口就是公共的行为规范标准，大家在实现时，只要符合标准就可以通用。在Java中，接口可以看成：多个类的公共规范，是一种引用数据类型。
2.2 语法规则
接口的定义格式与类的定义格式基本相同，将class关键字换成interface关键字，就定义了一个借口。
public interface 接口名称{
public abstract void method1(); //public abstract是固定搭配，可以省略不写
public void method2();
abstract void method3();
void method4(); //推荐这种风格
}
提示：
1. 创建接口时，接口的命名一般以大写字母I开头
2. 接口命名一般使用形容词词性的单词
3. 阿里编码规范中规定，接口中的方法属性不要加任何修饰符号，保持代码的简洁性
2.3 接口使用
接口不能直接使用，必须有一个实现类来实现该接口，实现接口中的所有抽象方法，这里使用关键字implements来实现。
public class 类名称 implements 接口名称{
//…
}
**注意：**子类父类是extends继承关系，接口与类之间是implements实现关系。
例子：
实现笔记本电脑使用USB鼠标，USB键盘的例子
1.USB接口：包含打开设备，关闭设备功能
2.笔记本类：包含开机功能，关机功能，使用USB设备功能
3.鼠标类：实现USB接口，并具备点击功能
4. 键盘类：实现USB接口，并具备输入功能
//USB接口
public interface USB {
void openDevice();
void closeDevice();
}
//鼠标类
public class Mouse implements USB{
@Override
public void openDevice() {
System.out.println(“打开鼠标”);
}
@Override
public void closeDevice() {
System.out.println(“关闭鼠标”);
}
public void click(){
System.out.println(“点击鼠标”);
}
}
//键盘类
public class KeyBoard implements USB{
@Override
public void openDevice() {
System.out.println(“打开键盘”);
}
@Override
public void closeDevice() {
System.out.println(“关闭键盘”);
}
public static void inPut(){
System.out.println(“键盘输入”);
}
}
//电脑类使用USB设备
public class Computer {
public void powerOn(){
System.out.println(“打开笔记本电脑”);
}
public void powerOff(){
System.out.println(“关闭笔记本电脑”);
}
public void useDevice(USB usb){
usb.openDevice();
if(usb instanceof Mouse){
Mouse mouse = (Mouse)usb;
mouse.click();
}else if(usb instanceof KeyBoard){
KeyBoard keyboard = (KeyBoard)usb;
KeyBoard.inPut();
}
usb.closeDevice();
}
}
//测试类
public class TestUSB {
public static void main(String[] args) {
Computer computer = new Computer();
computer.powerOn();
computer.useDevice(new Mouse());
computer.useDevice(new KeyBoard());
computer.powerOff();
}
}
2.4 接口特性
1. 接口是一种引用类型，但是不能直接new接口对象
public class TestUSB {
public static void main(String[] args) {
USB usb = new USB() ; //编译报错：USB是抽象的，无法实例化
}
2. 接口中的每一个方法都是public的抽象方法，即接口中东非方法会隐式的指定为public abstract（只能是这种，其他修饰符都会报错）
3. 接口中的方法不能在接口中实现，只能由实现接口的类来实现
public interface USB {
void openDevice();
void closeDevice(){
System.out.println(“关闭设备”); //编译错误，接口中的方法默认为抽象方法
}
}
4.重写接口方法时不能使用default访问权限修饰符
5.接口中可以含有变量，但接口中的变量会被隐式的指定为public static final 变量
6.接口中不能有静态代码块和构造方法
7.接口虽然不是类，但是编译完成后的字节码文件的后缀也是.class
8.如果类没有实现结合中的所有抽象方法，则类必须设置为抽象类
2.5 实现多个接口
在Java中类是单继承的，但是一个类可以实现多个接口
下面通过类表示一组动物
public class Animal {
protected String name;
public Animal(String name) {
this.name = name;
}
}
提供接口表示游，飞，跑
public interface ISwimming {
void swim();
}
public interface IFlying {
void fly();
}
public interface IRunning {
void run();
}
猫会跑
public class Cat extends Animal implements IRunning{
public Cat(String name){
super(name);
}
@Override
public void run() {
System.out.println(this.name+“正在跑”);
}
}
鱼会游
public class Fish extends Animal implements ISwimming{
public Fish(String name){
super(name);
}
@Override
public void swim() {
System.out.println(this.name+“正在游”);
}
}
青蛙能跑能游
public class Frog extends Animal implements IRunning,ISwimming{
public Frog(String name){
super(name);
}
@Override
public void run() {
System.out.println(this.name+“正在跑”);
}
@Override
public void swim() {
System.out.println(this.name+“正在游”);
}
}
注意：一个类在实现接口时，每个接口的抽象方法都要实现，否则必须设置成抽象类
鸭子：水陆空三栖动物
public class Duck extends Animal implements ISwimming,IRunning,IFlying{
public Duck(String name){
super(name);
}
@Override
public void fly() {
System.out.println(this.name+“在空中飞”);
}
@Override
public void run() {
System.out.println(this.name+“在地上跑”);
}
@Override
public void swim() {
System.out.println(this.name+“在水里游”);
}
}
2.6 接口间的继承
在Java中类与类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承，
接口之间可以继承，达到复用的效果，使用 extends 关键字。
public interface IRunning {
void run();
}
public interface ISwimming {
void swim();
}
public interface IAmphibious extends IRunning,ISwimming{
扫一扫
967
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
