抽象类、接口

抽象类

抽象类就是一个类中没有足够的信息去描述一件具体的事物。

抽象类的特点：

抽象类可以有构造方法，但是不能创建抽象类的对象。

抽象类可以拥有普通的、静态的属性和普通方法、静态方法。

抽象类可以定义抽象类，抽象方法只能有方法的声明，，不能有方法体，而且抽象方法要由子类来实现。

抽象方法的定义：public abstract 返回值类型 方法名(参数列表)；

如果子类没有实现父类中的抽象方法，那么子类也要定义成抽象类，由子类的子类来负责实现，以此类推。

定义抽象类使用abstract关键字，语法：

[访问修饰符] abstract class 类名{}

如果一个类中，有一个方法是抽象的，那么这个类一定是抽象类；但是抽象类中，不一定有抽象

方法

public class Demo8{ 
public static void main(String[]args){
 //Shape shape=new Shape(2,2);
 ZhengShape zs=new ZhengShape(3,3);
 System.out.println("面积："+zs.area()); 
zs.zhouChang();
 zs.t1(); 
Shape.t2(); 
} 
}
//定义抽象类
 abstract class Shape{
 double width;
 double height;
 public Shape(double width,double height){
 this.width=width;
 this.height=height;
 }
//定义抽象方法
 public abstract double area();
 public abstract void zhouChang();
 public void t1(){ 
System.out.println("----抽象类中的普通方法----");
 }
public static void t2(){
 System.out.println("----抽象类中的静态方法----");
 }
 }
class ZhengShape extends Shape{
 public ZhengShape(double w,double h){
 super(w,h); 
}
public double area(){
 return super.width*super.height; 
}
public void zhouChang(){
System.out.println("周长："+((super.width+super.height)*2));
}
}

接口

接口就是定义了一套规范，凡是使用这个接口的都要遵循接口中定义的规范

接口的特点：

接口使用关键字interface来定义，语法：

[访问修饰符] interface 接口名{}

接口中没有构造方法，也不能被实例化

接口中定义的变量实际是常量，因为都是 public static final 修饰的。public static fina可以省略

接口中定义的所有元素都是public修饰的

接口中只能定义抽象方法，JDK8之后新增加了默认方法、静态方法。

默认方法由default 修饰，由方法体，通过接口实现类的对象调用，语法：

[访问修饰符] default 返回值类型 方法名（参数列表）{方法体}

静态方法由static 修饰，在调用时通过接口名来调用。

默认方法如果有需要，实现类可以对其重写，在重写时 不用加default关键字

如果有两个接口中的静态方法一模一样，并且一个实现类同时实现了这两个接口，此时并不会

产生错误，因为 JDK8 只能通过接口名调用接口中的静态方法，所以对于 JVM 来说是可以区分

的。但是如果两个接口中定义了一模一样的默认方法，并且一个实现类同时实现了这两个接

口，那么必须在实现类中重写默认方法，否则编译失败。

接口可以实现多继承，依然是通过 extends 关键字，多个接口之间使用逗号分隔即可。如果继

承的多个接口中，有一模一样的默认方法，需要在子接口中对默认方法进行重写。

实现接口implements

接口需要由类来实现

[访问修饰符] class  类名 implements 接口1 ,接口2,.....{  }

public class Demo9{
 public static void main(String[]args){
 MyInterImpl1 my1=new MyInterImpl1();
 my1.t1();
 System.out.println(my1.display("张三",22));
 //调用接口中的默认方法

my1.m1(); 
//调用接口中的静态方法 
MyInter1.t3(); 
MyInter2.t3(); 
}
 }
//定义接口 
interface MyInter1{
 int NUM=10;// public static final int NUM=10;
 public static final int NUM2=20;
 //抽象方法
 public abstract void t1();
 public String display(String name,int age);
 default void m1(){ 
System.out.println("---接口MyInter1中的默认方法---");
 }
static void t3(){ 
System.out.println("---接口MyInter1中的静态方法---");
 }
 }
interface MyInter2{
 static void t3(){ 
System.out.println("---接口MyInter2中的静态方法---");
 }
default void m1(){
 System.out.println("---接口MyInter2中的默认方法---");
 }
 }
interface MyInter3 extends MyInter1,MyInter2{ 
public default void m1(){
 System.out.println("---重写接口中的默认方法----");
 } 
}
//实现接口
 class MyInterImpl1 implements MyInter3{
 public void t1(){ 
System.out.println("实现了接口中的抽象方法");
 }
public String display(String name,int age){
 return "姓名:"+name+",年龄:"+age; 
}
}