抽象类与接口

抽象类：

1.定义：一种专门用来做父类的、自身不能实例化的、只能被继承的类；注：抽象类不能实例化，不能new；

2.抽象类和抽象方法：

抽象方法：只有方法的声明而没有方法的实现，就是说方法的内部没有方法实体；

抽象类：抽象类中可以有也可以没有抽象方法；

抽象类和抽象方法的定义方法都是在类的名字和方法名之前加上abstract关键字；

实例：

abstract class Person{
public static final String country="China";
private String name;
public void setName(String name ){
this.name=name;
}
public String getName(){
return name;
}
public abstract void tell();
}
class Student extends Person{
public void tell (){
System.out.println("My name is " + getName() + "my country is " + country );
}
}
public class AbstractDemo01{
public static void main(String[] args){
Student stu = new Student();
stu.setName("Alex");
stu.tell();
}
}

3.抽象类的构造方法：

抽象类有自己的构造方法，因为他虽然自己不能创建实例对象，但是继承他的子类要创建对象是需要父

类的构造函数，所以父类也是必须有构造函数的，且子类可以用super访问和调用。

4.抽象类和普通类的区别：

一：抽象类不能调用自身的构造方法创建对象，必须先子类继承然后子类创建，但是普通的类可以自己

创建；

二：抽象类中可以包含抽象方法和非抽象方法，但是普通类只能包含非抽象方法；

5.抽象类（方法）注意事项：

一：抽象类需要被继承；

二：抽象方法无内容；

三：抽象类中可以不含、含有一个或多个抽象方法；

四：若一个类中含有抽象方法，那么这个类一定要被声明为抽象类；

五：若一个类继承了抽象类，必须实现其所有抽象方法，否则还是抽象类；

接口：

1.定义：接口是面向对象语言提供的抽象和封装的重要机制，接口主要的功能是描述类充当什么样的角

色，就是实现类的行为定义，用来约束类的行为，就像一个约定，让实现它的类都必须实现有些方法，

而且实现了它的类也可以自己添加其他方法；

2.接口的两个含义：

一：类的所有可以被外部访问的方法看作是接口；

二：用interface定义的接口；

3.接口的特点：

接口有自己的属性和方法，像类一样，可以接口之间相互继承，只是不用class定义，而用interface

定义，接口里面方法全部是抽象方法。接口定义时，interface前面默认public，数据前面默认public final

static，方法前面默认public abstract（方法后面没有实体就是说不能打{}，否则报错！）；且由于默认，

所以定义的时候，默认的可以不写；

public interface Example{
public static final int x=1;
public abstract void getArea();
public abstract void getCircum();
}


#########################################


public interface Example {
int x=1;
void getArea();
void getCircum();
}

//以上两者是一个道理；

4.实现与继承接口：

接口里面的方法都是抽象的，自然需要实现，实现接口的类必须实现接口中的所有抽象方法，用

implements关键字实现接口；

public interface Example{
public static final int x=1;
public abstract void getArea();
public abstract void getCircum();
}
public Real implements Example{
public Real(){}
public void getArea(){
System.out.println("real 1");
}
public void getCircum(){
System.out.println("real 2");//如果要用x的话：Example.x 即可；
}
}

抽象类也可以实现接口，但是不一定实现所有方法，继承抽象类的子类全部实现即可；

接口不能实现接口，但可以继承一个或多个接口：

interface InterP{
public static final float PI=3.14F;
}
interface InterArea{
public abstract void getArea();
}
interface InterCir{
public abstract void getCir();
}
interface InterVol extends InterP,InterArea,InterCir{
public abstract void getVol();
}
class Round implements InterVol{
private float radius;
public Round(){}
public Round(float radius){
setRadius();
}
public void setRadius(float radius ){
this.radius = radius;
}
public float getRadius(){
return radius;
}
public void getArea(){
System.out.println("S=" + (getRadius() * getRadius()*InterP.PI));
}
public void getCir(){
System.out.println("C=" + (2*getRadius()*InterP.PI));
}
public void getVol(){
System.out.println("V=" + (4/3 * InterP.PI * Math.
pow(getRadius(),3)));
}
}

5.接口和抽象类的比较：

相同点：

一：都可以包含抽象方法，且都要在实现接口或者继承的子类中全部实现；

二：都不能自己直接创建对象；

三：两者都可以实现继承（继承之后接口就有父类中所有的常量和方法，抽象类的子类有除去private之外的父类的内容）；

不同点：

一：接口用interface声明，抽像类用abstract；

二：接口中无变量，全是常量，抽象类中自己定义什么量就是什么量；

三：接口没有构造方法，抽象类有构造方法；

四：接口中方法全部都隐含public和abstract，即使不是显式修饰，编译器也会自动添加，接口中没有非抽象方法，

其方法也不能是最终的，静态的以及非public的；抽象类不自动添加任何修饰符，取决于开发人员自己，所以要手

动添加abstract关键字，抽象类可以有也可以没有抽象方法，若有则必须声明为抽象类，其抽象方法不能为最终的

静态的或是非public的；

五：interface没有内置的super和this关键字但是抽象类可以内置；

六：接口可以继承多个接口（多重继承），抽象类只能单继承，但可以重写父类方法或实现接口方法；