ICode9
精准搜索请尝试： 精确搜索
首页
编程语言>
数据库
系统相关
互联网
其他分享
Python
Java
JavaScript
android
PHP
首页 > 其他分享> 文章详细

六、抽象类和接口、类型和类型之间的关系

2020-09-25 21:00:48  阅读：234  来源： 互联网

标签：int void 接口 class 类型 抽象类 public


一、抽象类相关概念：

1.抽象类：将类和类之间共同特征提取出来，形成的就是抽象类。

2.抽象类的定义：

　　【修饰符列表】 abstract class 类名{

　　　　类体；

　　}

3.抽象方法：

　　表示没有实现的方法，没有方法体的方法。抽象方法必须在抽象类中。

　　如： public abstract void doSome();

4.抽象类是无法实例化的，无法创建对象的，故抽象类是用来被子类继承的。
5.抽象类虽然无法实例化，但是抽象类有构造方法，供子类使用(super)。
6.抽象类中不一定有抽象方法，但抽象方法必须出现在抽象类中。
7.子类继承抽象类，必须对抽象类中的所有抽象方法覆写/重写，也叫实现。非抽象方法可以不用重写。
8.final和abstract不能联合使用，这两个关键字是对立的。
abstract class Account{
    public abstract void doSome();//抽象方法
}

class CreditAccount extends Account{

    @Override
    public void doSome() {
        System.out.println("CreaditAccount");
    }
    
}

public class AbstractOne {

    public static void main(String[] args) {
        //Account a = new Account(); 抽象类无法实例化
        
        Account q = new CreditAccount();    //面向抽象编程
        q.doSome();
    }

}

二、接口

 1.1、接口是完全抽象的。（抽象类是半抽象）或者说是特殊的抽象类。
　　接口是一种引用数据类型，编译后也是一个class字节码文件。
1.2、接口的定义：
　　【修饰符列表】  interface 接口名 {  }
1.3、接口支持多继承。
1.4、接口中只有 常量 + 抽象方法。
1.5、接口都是public 修饰的（都是公开的）。
1.6、接口中的抽象方法/常量定义时：public abstract 修饰符可以省略。
interface A{
    
}

interface B{
    
}

interface C extends A,B{
    //多继承
}

interface MyMath{
//    public static final double PI = 3.14; 
    double PI = 3.14;
//    public abstract int sum(int a,int b);
    int sum(int a,int b);
}
2.1、类和类之间叫继承，类和接口之间叫实现（ implements ）。仍可看作"继承"。
2.2、一个类可以实现多个接口。（弥补多继承）
2.3、接口和接口之间进行强制类型转换的时候，没有继承关系，也可以强转。运行时可能出现 ClassCastException 异常。建议使用instanceof。
2.4、一个非抽象类，实现接口的时候，必须将接口中所有的方法实现。
interface MyMat{
    double PI = 3.14;
    public abstract int sum(int a,int b);
    int sub(int a,int b);
}

class Fa implements MyMat{
    //非抽象类，实现接口的时候，必须将接口中所有的方法实现。
    @Override
    public int sum(int a, int b) {
        return a+b;
    }

    @Override
    public int sub(int a, int b) {
        return a-b;
    }
    
}

abstract class Fb implements MyMat{
    //抽象类可以不用实现接口中的抽象方法
}

 

interface Aa{
    void m1();
}
interface Bb{
    void m2();
}
interface Cc{
    void m3();
}

class Dd implements Aa,Bb,Cc{
    //由于继承，故需要实现继承过来的所有的抽象方法
    @Override
    public void m3() {
        System.out.println("m3");
    }

    @Override
    public void m2() {
        System.out.println("m2");
    }

    @Override
    public void m1() {
        System.out.println("m1");
    }
    
}
class EE implements Aa{

    @Override
    public void m1() {
    }
    
}

public class Test {
    public static void main(String[] args) {
        Aa t = new EE();//多态
//        Bb tt = (Bb)t;     //EE与Bb没关系，但可以强转，不过会抛出异常
        System.out.println(t instanceof Bb);//false
        if(t instanceof Bb) {
            Bb tt1 = (Bb)t; 
        }
    }

}

 2.5、继承和实现可以共存。extends 在前， implements 在后。

class Animal{
    
}

//飞翔的接口
//接口通常提取的是行为动作
interface Flyable{
    void fly();
}

//通过接口插到猫身上，让猫fly；
class Cat extends Animal implements Flyable{

    @Override
    public void fly() {
        System.out.println("Cat Fly!!!");
    }
    
}

//不想让蛇飞，不去实现接口
class Snack extends Animal{
    
}

public class Test {

    public static void main(String[] args) {
        Flyable f = new Cat();//多态
        f.fly();
    }

}

2.6、接口在开发中的作用：解耦合

　　面向抽象编程，降低耦合度，提高扩展力。

2.7、面向抽象编程，面向接口编程。降低程序耦合度，提高扩展力，符合OCP开发原则。

　　开闭原则（Open-Closed Principle，简称 OCP）说的是：软件实体（类、模块、功能等）应该可以被扩展，但不可被修改。

　　开闭原则中的“开”，是指对于组件功能的扩展是开放的，是允许对其进行功能扩展的；开闭原则中的“闭”，是指对于原有代码的修改是封闭的，即不应该修改原有的代码。

　　开闭原则说白了就是，应该在不修改现有代码的基础上，引入新功能。

2.8、接口使用离不开多态机制。

2.9、抽象类和接口之间的区别：

　　　抽象类是半抽象的。

　　　接口时完全抽象的。

 

　　　抽象类中有构造方法。　

　　　接口中没有构造方法。

 

　　　接口和和接口之间支持多继承。

　　　类和类之间只能单继承。

 

　　　一个类可以实现多个接口。

　　　一个类只能继承一个抽象类。

　　

　　　一般接口使用的比抽象类多。接口一般都是对行为的抽象。

2.10、厨师 菜单 顾客的一个例子：

interface FoodMenu{
    void a();
    void b();
}
//中餐厨师
class Chinacooker implements FoodMenu{

    @Override
    public void a() {
        System.out.println("C做的A菜");
    }

    @Override
    public void b() {
        System.out.println("C做的B菜");
    }
    
}
//西餐厨师
class Americacooker implements FoodMenu{

    @Override
    public void a() {
        System.out.println("A做的A菜");
    }

    @Override
    public void b() {
        System.out.println("A做的B菜");
    }
    
}
//顾客手里有一个菜单
class Customer {
    private FoodMenu foodMenu;
//    Acooker ac;    这样写就写死了
//    Ccooker cc;
    
    public Customer() {
        super();
    }

    public Customer(FoodMenu foodMenu) {
        super();
        this.foodMenu = foodMenu;
    }

    public void orderA(){
        foodMenu.a();
    } 
    
    public FoodMenu getFoodMenu() {
        return foodMenu;
    }

    public void setFoodMenu(FoodMenu foodMenu) {
        this.foodMenu = foodMenu;
    }
    
    
}

public class Test {

    public static void main(String[] args) {
        Americacooker zhangsan = new Americacooker();
        Customer Arick = new Customer(zhangsan);
        Arick.orderA();
    }

}
View Code

三、类型与类型之间的关系：

　　is a（继承） 、has a（关联） 、 like a（实现）

1.is a ： 

　　Cat is a Animal （猫是一个动物）

　　但凡满足is a 的表示都可以设置为继承。

　　Cat extends Animal{}

2.has a ： 表示关联关系

　　Customer has a FoodMenu （顾客有一个菜单）

　　关联关系通常以属性的形式存在。

　　Customer {　　FoodMenu foodMenu； }

3.like a： 实现关系

　　Cooker like a FoodMenu（厨师像一个菜单一样）（司机像导航）

　　实现关系通常是：类实现接口。

　　Cooker implements B{}

 

【自行查阅】package和import

上一篇、六、抽象类和接口 

下一篇、持续更新中

 

标签：int,void,接口,class,类型,抽象类,public
来源： https://www.cnblogs.com/arick/p/13727383.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

关于我们 | 联系我们 | 留言反馈

专注分享技术，共同学习，共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有