JAVA面向对象 - 抽象类、接口

抽象类

抽象就是笼统、模糊、看不清、不具体。用abstract关键字来修饰一个类时，这个类就叫抽象类，用abstract关键字来修饰一个方式时，这个方法就是抽象方法。当一个类继承的父类是抽象类的话，需要我们把抽象类中的所有抽象方法全部实现。那为什么要用抽象类呢？当父类的一些方法不能确定时，可以先在抽象类里定义抽象方法。抽象类不可以被实例化，因为调用抽象方法没有意义。抽象类必须有其子类覆盖了所有的抽象方法后，该子类可以被实例化。否则,这个子类还是抽象类。

//抽象动物类
abstract class Animal
{
    abstract public void call;
    abstract public void eat;
}

//该类也是抽象类，没有完全实现Animal抽象类里面的所有方法
class dog extends Animal
{
    public void call()
    {
        System.out.println("dog call ..");
    }
}

 

注意事项

Ⅰ.抽象类不能被实例化

Ⅱ.抽象类不一定要包含abstract方法。

Ⅲ.一旦类包含了abstract方法，则这个类必须声明为abstract

Ⅳ.抽象类不能有主体

 

细节
1.抽象类中有构造函数吗？
有，用于给子类对象进行初始化的
2.抽象类可以不定义抽象方法吗?
可以的，但是很少见，目的就是不让该类创建对象。AWT适配器对象就是这种类。通常这个类中的方法有方法体，但没有内容。
class Dome
{
　　void show1(){}
　　void show2(){}
}
3.抽象类关键字不可以和那些关键字共存？
private ,static,final
4.抽象类和一般类的异同点？
相同点：
　　抽象类和一般类都是用来描述事物的，都在内部定了成员
不同点：
　　1.一般类有足够的信息描述事物
　　抽象类描述事物的信息有可能不足
　　2.一般类中不能定义抽象方法，只能定义非抽象方法
　　抽象类可以定义抽象方法，同时也可以定义非抽象方法
　　3.一般类可以被实例化
　　抽象类不可被实例化
5.抽象类一定是个父类吗？
是的，因为需要子类覆盖其方法可以对子类实例化。

实例

package com.beekc.www;

public class Beekc {
    public static void main(String[] args) {
        Animal an = new Dog();
        an.cry();
        an = new Cat();
        an.cry();
    }
}

//抽象类
abstract class Animal
{
    private int age;
    private String name;
    //抽象方法
    abstract public void cry();

}

class Cat extends Animal
{
    //继承了Animal，一点要实现cry方法
    public void cry()
    {
        System.out.println("猫猫，喵喵叫~");
    }
}

class Dog extends Animal
{
    //继承了Animal，一点要实现cry方法
    public void cry()
    {
        System.out.println("狗狗，汪汪叫~");
    }
}

 

运行结果

 

//实例二
//雇员类
abstract class Employee
{
    private String name;
    private String id;
    private float salary;
    
    Employee(String name, String id, float salaty)
    {
        this.name = namet;
        this.id = id;
        this.salary = salary;
    }
    
    abstract public void work();
}
//程序员类
class Programmer extends Employee
{
    Programmer(String name, String id, float salary)    
    {
        super(name,id,salary);
    }
    
    public void work()
    {
        System.out.println("code...");
    }
}
//项目经理类
class ProjectManager extends Employee
{
    private float bonus;
    
    ProjectManager(String name, String id, float salary,float bonus)
    {
        super(name,id,salary);
        this.bonus = bonus;
    }
    
    public void work()
    {
        System.out.println("Manager...");
    }
}

class EmployeeDome
{
    public static void main(String[] agrs)
    {
       ProjectManager projectManager = new ProjectManager("张三","007",10000,5000);
       Programmer programmer1 = new Programmer("李四","c003",8000);
       Programmer programmer2 = new Programmer("王五","c004",8000);
       Programmer programmer3 = new Programmer("赵六","c005",10000);
       
       projectManager.show();
       programmer1.show();
       programmer2.show();
       programmer3.show();
    }
}

 

接口

接口就是给出一些没有内容的方法，封装到一起，到某个类要使用的时候，在根据具体情况把这些方法写出来。接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体。接口体现了程序设计的多态和高内聚低偶合的设计思想。

对于接口常见的成员，而且这些都有固定的修饰符。但省略了这些固定的关键字不会报错。
　　1.全局变量： public static final
　　2.抽象方法： public abstract

interface Dome
{
    public static final int a =4;
    public abstract void show1();
}

 

定义格式

interface Demo{}

 

注意事项

Ⅰ.接口不能被实例化

Ⅱ.接口中所有的方法都不能有主体

Ⅲ.一个类可以实现多个接口

Ⅳ.接口中可以有变量，但变量不能用private和protected修饰

Ⅴ.一个接口不能继承其他的类，但是可以继承别的接口

 

接口的实现
关键字为implements。类与类之间是继承关系,类与接口直接是实现关系。在java中不直接支持多继承,因为会出现调用的不确定性。所以java将多继承机制进行改良,在java中变成了多实现。一个类可以实现多个接口.

interface Usb
{
    public abstract void show1();
}
interface Pic
{
    public abstract void show2();
}

class Dome implements Usb,Pic
{
    public static void main(String[] agrs){}
    public abstract void show1(){}
    public abstract void show2(){}    
}

 

细节

//要是实现的接口有两个或两个以上一模一样的抽象方法,会直接覆盖所有的方法.
interface A
{
    public abstract void show();
}
interface B
{
    public abstract void show();
}
class Dome implements A,B
{
    public abstract void show(){}
}

 

//要是实现的接口有两个或两个以上的抽象方法,但返回类型的修饰符不一样,会报错
//会报错的程序
interface A
{
    //void
    public abstract void show();
}
interface B
{
    //int
    public abstract int show();
}
class Dome implements A,B
{
    public abstract void show(){}
    public abstract int show(){} 
}

 

//一个类继承一个类的同时,还可以实现多接口
interface A
{
    public abstract void showA();
}
interface B
{
    public abstract void showB();
}

class Z
{
    String name;
    public void showZ();
}

class Dome extends Z implements A,B
{
   public abstract void showA(){}
   public abstract void ShowB(){}
}

 

//接口与接口之间是继承关系,并且接口可以多继承.
interface A
{
    public abstract void showA();
}

interface B
{
    public abstract void showB();
}

interface C extends A,B
{
    public abstract void showC();
}

 

 

实例

package com.beekc.www;

//定义一个叫Usb的接口，用interface关键字
interface Usb
{
    int a= 1;
    //定义两个方法
    public void start();
    public void stop();
}

//相机类继承一个接口,用implements关键字
class Camera implements Usb
{
    //继承了接口，一定要Usb接口里的方法
    public void start()
    {
        System.out.println("我是相机,开始工作了！");
    }
    public void stop()
    {
        System.out.println("我是相机,停止工作了！");
    }
}

//手机类继承一个接口,用implements关键字
class Phone implements Usb
{
    //继承了接口，一定要Usb接口里的方法
    public void start()
    {
        System.out.println("我是手机,开始工作了！");
    }

    public void stop()
    {
        System.out.println("我是手机,停止工作了！");
    }
}

//计算机
class Computer
{
    //开始使用接口
    public void useUsb(Usb usb)
    {
        usb.start();
        usb.stop();
    }
}


public class Beekc {
    public static void main(String[] args) {
        System.out.println(Usb.a);
        Computer computer = new Computer();
        Camera camera = new Camera();
        Phone phone = new Phone();
        computer.useUsb(camera);
        computer.useUsb(phone);
    }
}

 

运行结果

 

//实例二
interface Usb
{
    public abstract void open();
    public abstract void close();
}

class BookCP
{
    public static void main(String[] agrs)
    {
        useUSB(new Upan());
        useUSB(new Mouse());
    }
    
    public static void useUSB(Usb usb)
    {
        usb.open();
        sub.close();
    }
}

class Upan implements Usb
{
     public abstract void open()
     {
        System.out.println("Upan open");
     }
     public abstract void close()
     {
        System.out.println("Upan close");
     }
}

class Mouse implements Usb
{
     public abstract void open()
     {
        System.out.println("Mouse open");
     }
     public abstract void close()
     {
        System.out.println("Mouse close");
     }
}