抽象类与接口

1.抽象类

   （1）抽象类：含有抽象方法的类，抽象类一定是父类，有构造方法，不能实例化。

   （2）抽象类与抽象方法的关系：含有抽象方法的类一定是抽象类，抽象类不一定含有抽象方法。当不希望这个类被创建对象时，可以将这个类定义为抽象类，此时不含抽象方法。

   （3）抽象类与普通类的区别:

　　　　相同点：都是类，都在描述事物

　　　　不同点：A.抽象类不能创建对象，普通类可以

　　　　　　　　B.抽象类可以含有抽象方法，普通类不能含有抽象方法

　（4）抽象类的特点：

          A.抽象类不能创建对象（实例化），因为含有抽象方法----若能实例化，它就会调用抽象方法，而抽象方法没有实现，所以不可以

　　　 B.继承了抽象类的子类，没有重写父类中的抽象方法，那么该子类还是抽象类　　

   （5）abstract不能和哪些关键字同用：

　　　　A.final:修饰的方法不能被重写，abstract:修饰的方法必须被重写

　　　　B.static:修饰的方法可以通过类名调用，abstract:修饰的方法不能通过类名调用（不能实例化）

　　　　C.private:修饰的方法不可以被重写（private作用范围为本类，重写要在另一个类中进行），abstract:修饰的方法必须被重写

  （6）代码展示

 

 　　

/**
 * 抽象类的特点:
 * 1.抽象类不能创建对象（实例化），
 *   因为含有抽象方法----若能实例化，它就会调用抽象方法，而抽象方法没有实现，所以不可以
 * 2.继承了抽象类的子类，没有重写父类中的抽象方法，那么该子类还是抽象类
 *
 */

//计算圆形，矩形的面积
abstract class Shape{
    public abstract double getArea();
    
}
abstract class Circle extends Shape{
    private double radius;
    Circle(double radius){
        this.radius = radius;
    }
    //继承了父类的抽象方法，含有抽象方法，
20     // 如果没有重写该抽象方法，那么该类也是抽象类
21     //public abstract double getArea();
}

class Rectangle extends Shape{
    private double length;
    private double width;
    public Rectangle(double length,double width) {
        this.length = length;
        this.width = width;
    }
    public double getArea(){
        return length*width;
    }
}
public class AreaTest {

    public static void main(String[] args) {
        //Shape s = new Shape();抽象类不能实例化
        
        Rectangle r = new Rectangle(4.0, 3.0);
        System.out.print(r.getArea());
    }

}

 

　　　　

/**
 *需求:公司中的程序员有姓名，工号，薪水，工作内容
 *项目经理除了有姓名，工号，薪水，还有奖金，工作内容。
 *对给出需求进行数据建模 
 * 
 *
 */

abstract class Employee{
    private String name;
    private String id;
    private double money;
    
    public Employee(){}
    
    public Employee(String name,String id,double money){
        this.name = name;
        this.id = id;
        this.money = money;
    }
    
    public abstract void work();
}

class Programmer extends Employee{
    public Programmer(){}
    public Programmer(String name,String id,double money){
        super(name,id,money);
    }
    public void work(){
        System.out.println("写代码");
    }
}

class Manager extends Employee{
    private double bonus;//奖金
    public Manager(){}
    public Manager(String name,String id,double money,double bonus){
        super(name,id,money);
        this.bonus = bonus;
    }
    public void work(){
        System.out.println("管理程序员");
    }
}
public class AreaTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Programmer p = new Programmer("张三","001",1000.0);
        p.work();
        
        Manager m = new Manager("李四","002",1000.0,1000.0);
        m.work();
        
    }

}

 

2.接口

　(1)定义形式
　　interface 接口名
 　　{
 　　　　全局常量(public static final)
 　　　　抽象方法(public abstract)
 　　}

  (2)接口是可以多实现的

　　因为接口中的方法都是抽象的，都没有实现，在创建子类对象并调用该重写的抽象方法时很明确
　　就是调用重写之后的方法，不会出现调用的不确定性

　　接口解决了java单继承的问题

interface inter1{
	public static final int Num = 25;
	public abstract void show();
}

interface inter2{
	public abstract void fun();
	public abstract void show();
}

class MyTest implements inter1,inter2{
	@Override
	public void show() {
		System.out.println("show");
		
	}

	@Override
	public void fun() {
		// TODO Auto-generated method stub
		
	}
}

public class InterfaceTest {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		MyTest test = new MyTest();
		test.show();
		
		System.out.println(test.Num);
		System.out.println(MyTest.Num);
		System.out.println(inter1.Num);

	}

}

　　运行结果：　　　

　　　　show
　　　　25
　　　　25
　　　　25

3.抽象类与接口的区别:

一个类在继承的同时还可以去实现接口
 类和类之间是继承的关系
 类和接口之间是实现的关系

 通过继承可以得到该继承体系的基本功能
 通过实现接口可以得到继承体系之外的功能

 接口和接口之间是继承的关系，而且多继承
 　　interface inner1{}
 　　interface inner2{}
 　　interface inner3 extends inner1,inner2,inner3{}