一、抽象(abstract)：
1、抽象类：
使用abstract修饰的类就是抽象类;
相比于普通类抽象类增加了支持抽象方法的功能,但也丢失了创建实例的功能(抽象类中不能创建实例),其他普通类有的抽象类可以有。
抽象类的三个注意点:
①、虽然抽象类不能创建实例,但它依然有构造器(主要给其子类的构造器调用-子类至少调用父类构造器一次);
②、抽象类中可以没有抽象方法(可有可无);
③、抽象类总是不能创建实例/对象的 - 即使它没有包含抽象方法。
public abstract class TestAbstract{
private int age;
{
System.out.println("-这是个对象初始化块-");
}
public TestAbstract(){}
//虽然抽象类不能创建实例,但它依然有构造器(主要是供其子类构造器调用,至少调用一次)
//子类不使用super()时则隐式调用父类无参构造器,有super()则根据参数来决定。
public TestAbstract(int age){
this.age = age;
}
public static void main(String[] args){
System.out.println("Hello World!!");
//抽象类中不能创建实例,编译时即报错
//TestAbstract ta = new TestAbstract();
}
}
2、抽象方法:
使用abstract修饰且没有方法体的方法就是抽象方法。
注意点:
①、抽象方法不能有方法体 - 花括号内容(出现花括号没任何代码都算有方法体)；
②、abstract不能和final同时出现 - 因为abstract方法必须由子类去重写,而final修饰的方法又不允许重写,因此不能同时出现；
对于abstract类来说,该类主要用于派生子类,final修饰的类同样不允许被集成,因此也不能同时出现 - abstract和final是永远互斥的；
③、abstract与static不能同时修饰方法 - static修饰的方法编译时已经确定下来,无法让子类@Override；
④、abstract与private不能同时修饰方法 - private修饰的方法不能被子类访问,而abstract又要求方法必须由子类重写,所以两者是互斥的。
public abstract class TestAbstract2{
//抽象类相对于普通类除了不能创建实例,其他功能都是有的,普通方法等能存在。
public void info(){}
//抽象方法中不能有方法体-即使方法体内容为空
//public abstract void aa(){}
public abstract void test();
//abstract 与static不能同时修饰方法 - static修饰的方法编译时已经确定下来,无法让子类@Override
//public abstract static void bb();
//abstract方法必须由子类重写,而private又不能让子类访问所以出错
private abstract void cc();
}
三、抽象的作用：
抽象类的作用:主要是与"模版模式" 结合一起使用的。
比如有如下场景需求:程序要实现A方法,但A方法又需要调用B方法且B方法在该类中暂时不知道如何实现(因为其子类实现B方法的方法可能都不一样,因此B方法可定义成抽象方法)。
抽象类的子类一般要实现抽象父类提供的所有方法,否则该子类也只能是抽象类(这样就无实际意义~)
abstract class SpeedMeter{
//定义一个转动速度。
private double turnRate;
//抽象类的构造器主要用于被子类的构造器调用
public SpeedMeter(double turnRate){
this.turnRate = turnRate;
}
//对于private修饰的Field一般推荐设置个set和get方法,典型的封装
public void setTurnRate(double turnRate){
this.turnRate = turnRate;
}
public double getTurnRate(){
return this.turnRate;
}
//计算速度的方法
/*
这里就是模版模式,此处我们定义一个计算速度的模板:转速*周长
但此处并不清楚计算周长方法,所以此处把周长getSpeed()定义成抽象方法,子类只需提供计算周长的方法即可
计算周长的方法是有差异的,车轮:2*PI*半径等
*/
public abstract double getSpeed();
}
class CarSpeedMeter extends SpeedMeter{
private double radius;
public CarSpeedMeter(double radius,double turnRate){
super(turnRate);
this.radius = radius;
}
@Override
public double getSpeed(){
return 2 * radius * Math.PI;
}
}
class TankSpeedMeter extends SpeedMeter{
private double bianchang;
public TankSpeedMeter(double bianchang,double turnRate){
super(turnRate);
this.bianchang = bianchang;
}
//假设坦克的周长计算方法为 8 * 边长
@Override
public double getSpeed(){
return 8 * bianchang;
}
}
public class TestSpeedMeter{
public static void main(String[] args){
SpeedMeter sm = new CarSpeedMeter(20,2000);
System.out.println("汽车的速度为: " + sm.getSpeed());
SpeedMeter tk = new TankSpeedMeter(8,1000);
System.out.println("坦克的速度为: " + tk.getSpeed());
}
}
二、接口(interface)：
接口的作用非常丰富,接口往往是和设计模式结合一起使用的。
接口可以认为是一种"彻底"的抽象类,它是从多个相似的类中抽取出来的一种规范,接口体现的是规范。
接口体现的规范:如主板上各种不同类型的"插槽",无论接入的哪个厂商、型号的硬件都可以彼此进行通信(任何一套公开的标准/规范,需要通过接口来体现)。
接口定义语法:
[修饰符] interface 接口名{
//0~N 个Field、特殊的Field
//0~N 个抽象方法
//0~N 个内部类、内部接口、内部枚举类定义
}
[修饰符]：只能是public和默认省略,不能是protected因为接口在保外,而protected只能在包名进行访问
接口名: 由多个单词连缀而成,每个单词的首字母要大写,推荐以i开头(c#定义已i开头且是个不错的习惯)。
注意点:
①、接口不能有构造器,也不能有初始化块；
②、接口的Field默认有3个修饰符: public static final，无论你写或不写,反正都有这三个修饰符；
接口的Field定义时必须指定初始值 -- 接口Field默认有static final修饰，final修饰的变量只能被赋值一次，你不指定系统给你赋默认值0、0.0、null等。
③、接口的方法默认有2个修饰符:public abstract，无论你写与不写，反正都有这二个修饰符；
接口的方法不能有static，因为接口的方法默认有abstract修饰。
④、接口的内部类、内部枚举类、内部接口，默认有两个修饰符: public static
public interface iWalk{
int age = 33;
//接口中的Field默认有public static final修饰,必须在声明时指定初始值
//final修饰的变量必须在声明时/初始块中指定,但接口又不能有初始化块,那必须在声明时指定了
//String name;
//接口的所有成员都需要提供给外部类、包访问,接口公开的标准必须由public修饰
//private double weight = 99;
//接口中的方法默认有public abstract修饰
void info();
//抽象方法不能有方法体
//void test(){}
}
接口的继承：
一个接口可以有N个直接父接口;
接口可用于定义变量；不能直接创建实例；提供其他类来实现自己。
implements:实现一个或N个接口，接口实现类要么为接口所有的抽象方法提供实现，否则你的实现类也只能是抽象类。接口主要是在"面向接口编程"时提供更好、更灵活的机制。
interface IEatable{
void eat();
}
interface IFlyable{
void fly();
}
interface Iwalkable extends IEatable{
int age = 20;
void info();
/*
接口中的方法必须为抽象方法
public static void main(String[] args){
Iwalkable iw = new Sparrow();
}
*/
}
public class Sparrow implements IFlyable,Iwalkable{
//因为Sparrow实现了两个接口,所以它必须实现两个接口的所有方法
@Override
public void eat(){
System.out.println("这只麻雀在一口一口吃麦子");
}
public void fly(){
System.out.println("这麻雀在飞走了！");
}
public void info(){
System.out.println("这是一只小小麻雀");
}
public static void main(String[] args){
//向上转型,iw引用变量编译时只是Iwalkable类型,编译器只能允许它调用Iwalkable内的方法
Iwalkable iw = new Sparrow();
iw.info();
iw.eat();
//iw编译时为Iwalkable类型,直接调用fly方法会报错
//iw.fly();
//Sparrow sp = new Sparrow();
//强制向下转型
Sparrow sp = (Sparrow)iw;
sp.fly();
IFlyable ia = new Sparrow();
ia.fly();
}
}
接口与抽象类之间的相似之处:
①、都可以包含抽象方法；
②、都不能创建实例
③、子类抽象类或实现接口，都要求实现所有抽象方法，否则这个子类也只能是抽象类
接口与抽象类之间的区别：
①、接口里只能有抽象方法，而抽象类中可以没有抽象方法也可以包含普通方法；
②、接口中不能定义static方法，而抽象类中可以包含static方法；
③、接口的Field默认有public static final三个修饰符修饰，而抽象类的Field完全可以是普通Field；
④、接口不能包含构造器，而抽象类完全可以有构造器(供子类至少调用一次)；
⑤、接口不能包含初始化块，而抽象类完全可以有初始化块；
⑥、接口可以有多个直接的父接口，而抽象类只能有一个直接的父类。