JAVA面向对象 - 抽象类接口

Posted 2021-03-08 白客C

抽象类

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

 1 //抽象动物类
 2 abstract class Animal
 3 {
 4     abstract public void call;
 5     abstract public void eat;
 6 }
 7 
 8 //该类也是抽象类，没有完全实现Animal抽象类里面的所有方法
 9 class dog extends Animal
10 {
11     public void call()
12     {
13         System.out.println("dog call ..");
14     }
15 }

 

注意事项

Ⅰ.抽象类不能被实例化

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

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

Ⅳ.抽象类不能有主体

 

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

实例

 1 package com.beekc.www;
 2 
 3 public class Beekc {
 4     public static void main(String[] args) {
 5         Animal an = new Dog();
 6         an.cry();
 7         an = new Cat();
 8         an.cry();
 9     }
10 }
11 
12 //抽象类
13 abstract class Animal
14 {
15     private int age;
16     private String name;
17     //抽象方法
18     abstract public void cry();
19 
20 }
21 
22 class Cat extends Animal
23 {
24     //继承了Animal，一点要实现cry方法
25     public void cry()
26     {
27         System.out.println("猫猫，喵喵叫~");
28     }
29 }
30 
31 class Dog extends Animal
32 {
33     //继承了Animal，一点要实现cry方法
34     public void cry()
35     {
36         System.out.println("狗狗，汪汪叫~");
37     }
38 }

 

运行结果

 

 1 //实例二
 2 //雇员类
 3 abstract class Employee
 4 {
 5     private String name;
 6     private String id;
 7     private float salary;
 8     
 9     Employee(String name, String id, float salaty)
10     {
11         this.name = namet;
12         this.id = id;
13         this.salary = salary;
14     }
15     
16     abstract public void work();
17 }
18 //程序员类
19 class Programmer extends Employee
20 {
21     Programmer(String name, String id, float salary)    
22     {
23         super(name,id,salary);
24     }
25     
26     public void work()
27     {
28         System.out.println("code...");
29     }
30 }
31 //项目经理类
32 class ProjectManager extends Employee
33 {
34     private float bonus;
35     
36     ProjectManager(String name, String id, float salary,float bonus)
37     {
38         super(name,id,salary);
39         this.bonus = bonus;
40     }
41     
42     public void work()
43     {
44         System.out.println("Manager...");
45     }
46 }
47 
48 class EmployeeDome
49 {
50     public static void main(String[] agrs)
51     {
52        ProjectManager projectManager = new ProjectManager("张三","007",10000,5000);
53        Programmer programmer1 = new Programmer("李四","c003",8000);
54        Programmer programmer2 = new Programmer("王五","c004",8000);
55        Programmer programmer3 = new Programmer("赵六","c005",10000);
56        
57        projectManager.show();
58        programmer1.show();
59        programmer2.show();
60        programmer3.show();
61     }
62 }

 

接口

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

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

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

 

定义格式

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(){}    
}

 

细节

 1 //要是实现的接口有两个或两个以上一模一样的抽象方法,会直接覆盖所有的方法.
 2 interface A
 3 {
 4     public abstract void show();
 5 }
 6 interface B
 7 {
 8     public abstract void show();
 9 }
10 class Dome implements A,B
11 {
12     public abstract void show(){}
13 }

 

//要是实现的接口有两个或两个以上的抽象方法,但返回类型的修饰符不一样,会报错
//会报错的程序
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(){}
}

 

 1 //接口与接口之间是继承关系,并且接口可以多继承.
 2 interface A
 3 {
 4     public abstract void showA();
 5 }
 6 
 7 interface B
 8 {
 9     public abstract void showB();
10 }
11 
12 interface C extends A,B
13 {
14     public abstract void showC();
15 }

 

 

实例

 1 package com.beekc.www;
 2 
 3 //定义一个叫Usb的接口，用interface关键字
 4 interface Usb
 5 {
 6     int a= 1;
 7     //定义两个方法
 8     public void start();
 9     public void stop();
10 }
11 
12 //相机类继承一个接口,用implements关键字
13 class Camera implements Usb
14 {
15     //继承了接口，一定要Usb接口里的方法
16     public void start()
17     {
18         System.out.println("我是相机,开始工作了！");
19     }
20     public void stop()
21     {
22         System.out.println("我是相机,停止工作了！");
23     }
24 }
25 
26 //手机类继承一个接口,用implements关键字
27 class Phone implements Usb
28 {
29     //继承了接口，一定要Usb接口里的方法
30     public void start()
31     {
32         System.out.println("我是手机,开始工作了！");
33     }
34 
35     public void stop()
36     {
37         System.out.println("我是手机,停止工作了！");
38     }
39 }
40 
41 //计算机
42 class Computer
43 {
44     //开始使用接口
45     public void useUsb(Usb usb)
46     {
47         usb.start();
48         usb.stop();
49     }
50 }
51 
52 
53 public class Beekc {
54     public static void main(String[] args) {
55         System.out.println(Usb.a);
56         Computer computer = new Computer();
57         Camera camera = new Camera();
58         Phone phone = new Phone();
59         computer.useUsb(camera);
60         computer.useUsb(phone);
61     }
62 }

 

运行结果

 

 1 //实例二
 2 interface Usb
 3 {
 4     public abstract void open();
 5     public abstract void close();
 6 }
 7 
 8 class BookCP
 9 {
10     public static void main(String[] agrs)
11     {
12         useUSB(new Upan());
13         useUSB(new Mouse());
14     }
15     
16     public static void useUSB(Usb usb)
17     {
18         usb.open();
19         sub.close();
20     }
21 }
22 
23 class Upan implements Usb
24 {
25      public abstract void open()
26      {
27         System.out.println("Upan open");
28      }
29      public abstract void close()
30      {
31         System.out.println("Upan close");
32      }
33 }
34 
35 class Mouse implements Usb
36 {
37      public abstract void open()
38      {
39         System.out.println("Mouse open");
40      }
41      public abstract void close()
42      {
43         System.out.println("Mouse close");
44      }
45 }