0


深入理解面向对象(第一篇)

🏀面向对象

🥅final 关键字

⭐️final修饰的类无法继承。
⭐️final修饰的方法无法覆盖(构造方法不能被 final 修饰)。
⭐️final修饰的变量只能赋一次值。
⭐️final修饰的引用一旦指向某个对象,则不能再重新指向其它对象,但该引用指向的对象内部的数据是可以修改的。
⭐️final修饰的实例变量必须手动初始化,不能采用系统默认值。
⭐️final修饰的实例变量一般和static联合使用,称为常量。
例如:public static final double PI = 3.1415926;

❤️例1:final修饰:局部变量、方法、类

(1)final是java语言中的一个关键字;final表示:最终的,不可变的。
(2)final修饰的变量?
⭐️对于局部变量要想调用必须手动赋值;
⭐️对于实例变量可以不进行赋值,系统会自动赋默认值
⭐️final修饰的局部变量,一旦赋值不能重新赋值!
⭐️final修饰的实例变量,只能赋一次值!
(3)final修饰的方法?
⭐️ final修饰的方法无法被覆盖、不能重写!
(4)final修饰的类?
⭐️ final修饰的类无法继承!
⭐️ final控制不了能不能调用的问题,final修饰的是最后的、不可变的、不能改的

public class FinalTest01{
    public static void main(String[] args) {
/*
        对于局部变量,不会默认赋初始值,只要不调用,不赋初始值也能编译通过
        加上final修饰也是如此,只不过final修饰过后就不能修改了!
*/
        //-----------1.局部变量正常使用和修改
        int x;// 只要不调用x,编译和运行都是没问题
        int i = 100;
        i = 200;
        System.out.println(i);
        
        //-----------2.用final修饰,并给变量直接赋初始值
        final int y; //没问题
        final int k = 10;
        //k = 100; //err不能在更改
        System.out.println(k);
        
        //-----------3.用final修饰,给变量赋初始值的另一种方法
        //先定义出来,在赋初始值,分成两步也是没问题的
        final int n;
        n = 5;
        //n = 50;//在更改就不行了

    }
}

//4.final修饰的方法无法被覆盖
class C{
    public final void doSome(){ //被final修饰的方法
    System.out.println("C的doSome");
    }
}
//err;D中的doSome()无法覆盖C中的doSome()被覆盖的方法为final
class D extends C{
     public void doSome(){
     System.out.println("D的doSome");
    }
 }

//5.final修饰的类无法继承!
final class A{ //被final修饰,表示没有子类
}
//B类继承A类,相当于A类的功能扩展;如果不希望别人继承A类;可以给A类加final关键字进行修饰
//错误:无法从A类进行继承
class B extends A{
}

❤️例2:final修饰引用

final修饰的变量只能赋一次值;如果这个变量是一个引用呢?
(1)final修饰的引用:该引用只能指向一个对象,并且它只能永远指向该对象
无法在指向其它对象;即这个引用不能在指向一个新new的对象
(2)并且在该方法执行过程中,该引用指向对象之后,该对象不会被垃圾回收器GC回收
直到当前方法结束,才睡释放
(3)虽然final修饰的引用指向对象A后,不能在指向对象B但是对象A内部的数据还是能修改的!

public class FinalTest02 {
    public static void main(String[] args) {
     //1.-------正常使用
        Person p = new Person(30);
        System.out.println(p.age);//30
        
     //2.-------final修饰p1指向的对象不能变,p1存的是内存地址
        final Person p1 = new Person(20);
        //和数字20没关系,只要你new就会创建一个对象,开辟新的空间,新的内存地址
        p1 = new Person(20); //err;相当于把开辟出来的新空间地址,赋值给p1(本身是指向一块内存地址的)
     //3.-------但是对象内部的数据是可以变的
        p1.age = 50;
        System.out.println(p1.age);
    }
}

class Person{
    int age;
    //构造方法
    public Person() {
    }
    public Person(int age) {
        this.age = age;
    }
}

⭐️内存图理解

❤️例3:final修饰实例变量

(1)对于实列变量如果没有赋值,系统会默认赋默认值
(2)但是final修饰的实例变量,系统不会赋上默认值,要求程序员必须手动赋值
这个手动,在变量后面直接赋值可以;在构造方法中赋值也可以!
(3)结论:实例变量进行初始化是在构造方法执行的过程中(创建(new)对象的时候);final修饰的实例变量,必须手动值;只要在系统默认赋初始值之前赋值就都可以;也就是在构造方法执行过程中之前!

public class FinalTest03 {
    public static void main(String[] args) {

    }
}

class User{
  //1.------正常使用,就算不赋初始值,系统也会默认赋值
    int age;//实例变量,系统会默认赋上默认值
    int age1 = 10;//不使用系统默认值,就自己手动赋值
  
//2.------final修饰的实例变量,系统就不会默认赋上默认值;因为final修饰只能赋一次值;
    //如果赋默认值,程序员就不能再手动赋值了
    final int age;//err,必须手动赋值;并且在系统默认赋值之前赋值都是可以的
    //2.1.---只能手动赋上初始值;在这里赋上值,其实也是赶在系统赋默认值之前给它赋上;
        //所以也可以在构造方法中在赋值也是可以的!因为赋默认值是在构造方法执行的过程中
    final int age1 = 0; //正确 
    //2.2.---也可以在无参构造方法中赋值
    //在回顾一下实列变量在什么时候赋值?
      //构造方法执行的过程中(创建(new)对象的时候)
    final double weight; 
    public User(){
        //赶在系统赋默认值之前给它赋值就可以,而赋默认值是在执行构造方法执行的过程中
        this.weight = 1.8;
        //无参构造系统默认也会给它赋上默认值;我们在它赋上默认值之前给它赋值,
       //也是说的通的;这样系统不会给它赋默认值了
        //this.weight = 0.0;//系统赋默认值
    }
    //weight = 1.8;//err;不借助于构造方法赋值,直接赋值也是错误的
  
 //3.------当然也可以使用有参构造方法赋值
    public User(double d){
        this.weight = d;
    }
}

❤️例4:常量

(1)final修饰的实例变量,必须手动赋值;并且只能赋值一次,不会改变;既然永远不会改变,就没必要在声明为实例变量,在堆区创建就比较浪费空间;最好是静态的,在方法区,节省空间!
(2)结论:

**⭐️**所以final修饰的实例变量一般也要加上static修饰;
 **⭐️****static final联合修饰的变量成为“常量”**;常量名建议全部大写;每个单词之间采用下划线衔接
 **⭐️****实际上常量和静态变量一样,区别在于:常量的值不能改变;常量和静态变量,都是存储在方法区,并且都是在类加载时初始化**
 **⭐️****常量一般都是public公开的**
public class FinalTest04 {
    public static void main(String[] args) {
        System.out.println(Chinese.COUNTRY);//既然被static修饰,那么就用“类名.”访问
    }
}

class Chinese{
    String IdCard; //身份证号,每个人都不一样,对象级别的
    String name;//对象级别的
    //国家,固定值:“中国”;类级别的
    //final修饰的实例变量必须手动赋值;并且只能赋值一次,不会改变!
    //实例变量在堆中,一个对象就一份;比较浪费空间
    //实例变量既然使用final修饰,说明该实例变量不会随着对象的变化而变化
    //final String country = "中国"; //声明为实例变量,比较浪费空间

    //既然final修饰的永远不会改变,就没必要在声明为实例变量;最好是静态的,节省空间
    static final String COUNTRY = "中国";//声明为静态变量
}

//常量一般都是公开的;所以家伙加上public
class MyMath{ //π永远不会变,定义为常量
    public static final double PI = 3.1415926;//加上public修饰,一般都是公开的
}

🥅抽象类(abstract)

1、什么是抽象类?
(1)类和类之间具有相同特征,将这些共同特征提取出来,形成的就是抽象类。
(2)类本身是不存在的,所以抽象类无法创建对象。(无法实例化)
(3) 回顾:类到对象是实例化,对象到类是抽象。

2、抽象类属于什么类型?
抽象类也属于引用数据类型

3、抽象类怎么定义?

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

4、抽象类是无法实例化的,无法创建对象的,所以抽象类是用来被子类继承的
5、final和abstract不能联合使用,这两个关键字是对立的
6、抽象类的子类还可以是抽象类,也可以是非抽象类
7、抽象类虽然无法实例化,但是抽象类有构造方法,这个构造方法供子类使用的
8、抽象类关联到一个概念:抽象方法
(1)抽象的方法表示没有实现的方法,没有方法体的方法;
(2)例如:public abstract void doSome();
(3)抽象方法特点:
特点1:没有方法体,以分号结尾
特点2:前面修饰符列表中有abstract关键字

9、抽象类中不一定有抽象方法;但抽象方法必须出现在抽象类中
抽象类中既可以有抽象方法,也可以有非抽象方法
非抽象类中只能有非抽象方法发,不能有抽象方法

10、面试题:java语言中凡是没有方法体的方法都是抽象方法
答:错误的。Object类中就有很多方法都没有方法体,都是以“;”结尾的,但他们都不是抽象方法,例如: public native int hashCode(); 这个方法底层调用了C++写的动态链接库程序。前面修饰符列表中没有:abstract。有一个native。表示调用JVM本地程序。

❤️例1

public class AbstractTest01 {
    public static void main(String[] args) {
        // Account是抽象的; 无法实例化;不能new对象
        // Account a = new Account();//抽象类无法实例化

    }
}
//银行账户类---抽象类:可以有构造方法、抽象方法、非抽象方法
abstract class Account{
    public Account() {//无参构造
    }
    public Account(String s) { //有参构造
    }
    // 非抽象方法
    public void doOther(){

    }
    // 抽象方法
    public abstract void withdraw();
}

/*
class CreatAccount extends Account{
    public CreatAccount() {
        super();//无参构造默认有super()调用父类的无参构造方法
    }
}
*/

/*
//1.非法的修饰符组合: abstract和final
final abstract class Account{

}*/

/*
//2.非抽象子类继承抽象类,子类可以实例化对象
class CreatAccount extends Account{

}*/

/*
//3、抽象类的子类还可以是抽象类
abstract class CreatAccount extends Account{

}*/

❤️例2

1、抽象类不一定有抽象方法,抽象方法必须出现在抽象类中!

2、重要结论:一个非抽象的类继承抽象类,必须把抽象类中的抽象方法实现了

** **这里的覆盖或者说重写,也可以叫做实现(对抽象的实现)

public class AbstractTest02 {
    public static void main(String[] args) {
        //也可以使用多态:父类型引用指向子类型引用;这里是向上转型(自动类型转换)
        Animal a = new Bird();//这就是面向抽象编程
        //a的类型是Animal,Animal是抽象的;
        //面向抽象编程,不要面向具体编程,降低程序的耦合性,提高程序的扩展力
        //这种编程思想符合OCP原则
        a.move();
        //编译的时候是父类Animal的move()
        //运行的时候是子类Bird的move()

        //---练手;多态
        Animal a1 = new Cat();//调用的是默认的无参构造方法
        a1.move();
    }
}

// 动物类(抽象类)-----------------父类
abstract class Animal{
    //抽象方法
    public abstract void move();
}

/*err
// 子类(非抽象类)---Bird不是抽象的, 并且未覆盖Animal中的抽象方法move()
class Bird extends Animal{
}
//Animal是父类,并且是抽象的;Animals这个抽象类中有一个抽象方法move
//Bird是子类,是非抽象的;Bird继承Animals之后,会将抽象方法继承过来
*/

/*正确-------------方法重写/覆盖
class Bird extends Animal{
    //需要将从父类继承过来的抽象方法进行覆盖/重写;
    //或者也可以叫做“实现”;把抽象方法实现了
    public void move(){

    }
}*/

/*正确-------------子类写成抽象类
//如果Bird是抽象类的话,那么这个Animal中继承过来的抽象方法也可以不去重写/覆盖/实现
abstract  class Bird extends Animal{
}*/

//-----------------子类
class Bird extends Animal{
    //需要将从父类继承过来的抽象方法进行覆盖/重写;
    //或者也可以叫做“实现”;把抽象方法实现了
    public void move(){
        System.out.println("鸟儿在飞翔");
    }
}

//再写一个炼手
class Cat extends Animal{
    public void move(){
        System.out.println("猫儿在走猫步");
    }
}

🥅接口(interface)

❤️接口基础语法

1、接口也是一种引用数据类型;编译过后也生成一个class字节码文件
2、接口是完全抽象的,或者说接口是特殊的抽象类(抽象类是半抽象)
3、接口怎么定义?语法是什么?

  【修饰符列表】 interface 接口名{
    }

4、接口支持多继承,一个接口可以继承多个接口;但是类不支持多继承!
5、接口中只包含两部分内容:
第一部分:常量
第二部分:抽象方法 +-
6、接口中所有的元素都是public修饰的(都是公开的)
7、接口中的抽象方法定义时:public abstract修饰符可以省略
8、接口中的常量的public static final可以省略;所以接口中随意写一个变量就是常量
9、接口中的方法都是抽象方法,所以接口中的方法不能有方法体

⭐️例1:

public class InterfaceTest01 {
    public static void main(String[] args) {
        //访问接口的常量
        System.out.println(MyMath.PI);//接口也是一个类,用“接口.”调用

    }
}

//定义接口
interface A{ //生成A.class字节码文件
}
//在定义一个接口
interface B{ //生成B.class字节码文件
}
//接口支持多继承
interface C extends A,B{ //生成C.class字节码文件
}

//我的数学接口
interface MyMath1{
    //常量
    //public static final double PI = 3.1415926;
    //另一种写法:public static final可以省略
    double PI = 3.1415926;

    //抽象方法
    public abstract int sum(int x, int y);
    //另一种写法:public abstract可以省略
    int sub(int x, int y);

   /* ----就是把分号改成大括号err
   //接口中的方法不可以有方法体
    void doSome(){

    }*/
}

⭐️例2:接口中方法都是public

1、类和类之间叫做继承,类和接口之间叫做实现。实现就可以看作继承:
继承使用extends关键字完成 ;实现使用implements关键字完成

2、当一个非抽象的类实现接口的话,必须将接口中所有的抽象方法全都实现(覆盖、重写)

public class InterfaceTest02 {
    public static void main(String[] args) {

    }
}

//特殊的抽象类,完全抽象的,叫做接口
interface MyMath01{
    double PI = 3.1415926;//省略了public static final
    int sum(int a,int b);//抽象方法,省略了public abstract
    int sub(int a,int b);
}

//编写一个非抽象类去实现接口

/*
//1.err----会像继承一样把抽象方法继承过来,编译错误
class MyMathImp implements MyMath01 {

}*/

/*//2、修改方法1--用抽象类去实现接口(不常用)
abstract class MyMathImp implements MyMath01 {

}*/

//3、修改方法2---将方法进行覆盖、重写(常用)
class MyMathImp implements MyMath01 {
    public int sum(int a,int b){
        return a+b;
    }
    public int sub(int a,int b){
        return a-b;
    }

  /*//如果把public省略?我们以前讲过,继承不能让访问权限更低
  //err,正在尝试分配更低的访问权限,以前为public----抽分说明了接口中的方法都是public(公共的)
  
  //父类为public子类必须也是public,不能省略不写!
    int subb(int a,int b){
        return a-b;
    }*/

}

⭐️例3:接口和多态联合使用

public class InterfaceTest03 {
    public static void main(String[] args) {
        //使用多态---父类型的引用指向子类型的对象
        Math01 m = new MathImp();
        //调用接口里面的方法(面向接口编程)
        System.out.println(m.sum(10,20));
        System.out.println(m.sub(10,20));

    }
}

//----接口
interface Math01{
    double PI = 3.1415926;//省略了public static final
    int sum(int a,int b);//抽象方法,省略了public abstract
    int sub(int a,int b);
}

//----实现
class MathImp implements Math01 {
    public int sum(int a,int b){
        return a+b;
    }
    public int sub(int a,int b){
        return a-b;
    }

}

⭐️例4:一个类可以实现多个接口(重点)

(1)类和类之间不支持多继承!
(2)接口支持多继承,一个接口可以继承多个接口!
(3)一个类可以实现多个接口!

1、 接口和接口之间支持多继承,一个类可以同时实现多个接口 ;
例如:对计算来说,一个机箱上有多个接口,一个接口是接键盘的,一个接口是接鼠标的,一个接口是接电源的,一个接口是接显示器的 ;
2、一个类可以实现多个接口,这种机制实际上弥补了单继承(类和类)带来的缺陷;
3、接口和接口之间在进行强制类型转换的时候,没有继承关系,也可以强转;但需要注意的是:运行时可能会出现ClassCastException异常 ;
4、之前有一个结论:无论是向上转型还是向下转型,两种类型必须有继承关系, 没有继承关系编译器会报错 ;对于接口没有继承关系也可以,最终实际上和之前还是一样:需要加instanceof运算符进行判断;向下转型养成好习惯,转型之前先if+instanceof进行判断!

public class InterfaceTest04 {
    public static void main(String[] args) {
        AA a = new DD();
        BB b = new DD();
        CC c = new DD();

        //那么通过接口a能调用接口b里面的m2()吗?----通过向下转型
        //这个编译没问题,运行也没问题
        //调用其他接口中的方法,你需要转型(接口转型)
        BB b2 = (BB)a;
        b2.m2();
        //-----------也可以直接转成DD
        DD d = (DD)a;
        d.m2();

//-----------------------------------
        //多态---父类型的引用指向子类型的对象
        M m = new E();
        //把m类型转换成K类型----实际上这两个接口与没关系
        //接口和接口之间在进行强制类型转换的时候,没有继承关系,也可以强转
        //但需要注意的是:运行时可能会出现ClassCastException异常
        if(m instanceof K){
            K k = (K)m;
        }

    }
}

interface K{

}
interface M{

}
class E implements K,M{

}

//---------------------------------------------
/*//1.---------接口与接口之间支持多继承
interface X{

}
interface Y{

}
interface Z extends X,Y{

}*/
//------------------------------------------------

//2.----------一个类可以是实现多个接口
//实现多个接口,其实就是类似于多继承
interface AA{
    void m1();
}

interface BB{
    void m2();
}

interface CC{
    void m3();
}

class DD implements AA,BB,CC{
    //注意要把接口里面的所有方法重写,因为接口的方法都是抽象的;但这个类不是抽象的
    public void m1(){

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

    }

}

⭐️例5:extends和implement同时出现

继承和实现都存在的情况:extends关键字在前;implements关键字在后

public class InterfaceTest05 {
    public static void main(String[] args) {
        // 创建对象(表面上看Animals类没起作用)
        Flyable f = new Cat1();//多态
        f.fly();

       //同一个接口,调用同一个fly()方法,最后的执行效果不同
        Flyable f2 = new Pig();
        f2.fly();

    }
}

//动物类:子类
class Animals{

}
//接口
interface Flyable{
    void fly();
}

//猫类---子类
//Flyable是一个接口,是一对翅膀的接口,通过接口插到猫身上,让猫可以飞翔
class Cat1 extends Animals implements Flyable{
    public void fly(){
        System.out.println("猫可以飞翔");
    }
}

//假设有一个蛇类--我们不让他飞,就不实现Flyable接口
class Snak extends Animals{

}
//假设有一个猪类---我们让它飞,就实现Flyable接口
class Pig extends Animals implements Flyable{
    public void fly(){
        System.out.println("小猪会飞");
    }
}

//假如我们不写继承Animals,默认是继承Object的
class Fish implements Flyable{ //没写extends也是有的,默认继承Object
    public void fly(){

    }
}

**总结接口的基础语法。
** 1、接口是一种“引用数据类型”。
2、接口是完全抽象的。
3、接口怎么定义:[修饰符列表] interface 接口名{}
4、接口支持多继承。
5、接口中只有常量+抽象方法。
6、接口中所有的元素都是public修饰的
7、接口中抽象方法的public abstract可以省略。
8、接口中常量的public static final可以省略。
9、接口中方法不能有方法体。
10、一个非抽象的类,实现接口的时候,必须将接口中所有方法加以实现
11、一个类可以实现多个接口
12、extends和implements可以共存,extends在前,implements在后
13、使用接口,写代码的时候,可以实用多态(父类引用指向子类型对象)

❤️接口在开发中的作用

⭐注意:接口在开发中的作用,类似于多态在开发中的作用。
⭐多态:面向抽象编程,不要面向具体编程。降低程序的耦合度。提高程序的扩展力。

 public class Master{
                public void feed(Dog d){}
                public void feed(Cat c){}
                //假设又要养其它的宠物,那么这个时候需要再加1个方法。(需要修改代码了)
                //这样扩展力太差了,违背了OCP原则(对扩展开放,对修改关闭。)
            }
  public class Master{
                public void feed(Animal a){
                    // 面向Animal父类编程,父类是比子类更抽象的。
                    //所以我们叫做面向抽象编程,不要面向具体编程。
                    //这样程序的扩展力就强。
                }
            }

⭐接口在开发中的作用?
(1)接口是完全抽象的!而我们以后正好要求,面向抽象编程。
(2)面向抽象编程这句话以后可以修改为:面向接口编程。
(3)有了接口就有了可插拔。可插拔表示扩展力很强。不是焊接死的。

  (4)例如:主板和内存条之间有插槽,这个插槽就是接口,内存条坏了,可以重新买一个换下来。这叫做高扩展性。(低耦合度。)

⭐接口在现实世界中是不是到处都是呢?
例如:usb接口
螺栓和螺母之间有接口
灯泡和灯口之间有接口
笔记本电脑和键盘之间有接口
⭐接口有什么用?扩展性好。可插拔。接口是一个抽象的概念。
举例分析:中午去饭馆吃饭,这个过程中有接口吗?
(1)接口是抽象的。
(2)菜单是一个接口。(菜单上有一个抽象的照片:西红柿炒鸡蛋)
(3)谁面向接口调用。(顾客面向菜单点菜,调用接口。)
1、谁负责实现这个接口。(后台的厨师负责把西红柿鸡蛋做好!是接口的实现者。)
2、这个接口有什么用呢?
(1)这个饭馆的“菜单”,让“顾客”和“后厨”解耦合了。
(2)顾客不用找后厨,后厨不用找顾客。他们之间完全依靠这个抽象的菜单沟通。
总结一句话:三个字“解耦合”
1、 面向接口编程,可以降低程序的耦合度,提高程序的扩展力。符合OCP开发原则。
2、接口的使用离不开多态机制。(接口+多态才可以达到降低耦合度。)

    3、 接口可以解耦合,解开的是谁和谁的耦合?
          (1)任何一个接口都有调用者和实现者。
          (2)接口可以将调用者和实现者解耦合。
          (3)调用者面向接口调用。
          (4)实现者面向接口编写实现。

    4、以后进行大项目的开发,一般都是将项目分离成一个模块一个模块的,模块和模块之间采用接口衔接。降低耦合度。

⭐例1(面向接口编程)

顾客去餐馆吃饭,通过菜单这个接口,让顾客和厨师产生联系;降低耦合度!

/*
Cat is a Animal 但凡满足is a的表示都可以设置为继承!
Customer has a FoodMenu 但凡能够使用has a 来描述的,统一以属性的方式存在!
Cooker like a  FoodMenu  但凡能够使用like a 来描述的,是接口的实现者
*/

public class InterfaceFoodMenu {
    public static void main(String[] args) {
        //创建厨师对象
        //FoodMenu cooker = new ChinaCooker(); //多态
        //如果想换厨师
        FoodMenu cooker = new AmericCooker();
        //创建顾客对象
        Customer customer = new Customer(cooker);//传什么样的厨师,最后调用的就是谁做的菜
        //顾客点菜
        customer.order();

    }
}

//定义菜单接口----------围绕着接口编写
interface FoodMenu{ //接口里面都是抽象方法
    //西红柿炒鸡蛋
    void xiHongShiChaoJiDan();
    //鱼香肉丝
    void yuXiangRouSi();
}

//顾客---有菜单接口(调用接口)
class Customer{
    FoodMenu foodmenu; //顾客有菜单

    //构造方法
    public Customer() {
    }
    public Customer(FoodMenu foodmenu) {
        this.foodmenu = foodmenu;
    }

    //setter and getter
    public FoodMenu getFoodmenu() {
        return foodmenu;
    }

    public void setFoodmenu(FoodMenu foodmenu) {
        this.foodmenu = foodmenu;
    }

    //调用菜单的方法
    public void order(){
        //使用getFoodmenu()方法获取菜单
        FoodMenu fm = this.getFoodmenu();
        fm.xiHongShiChaoJiDan();
        fm.yuXiangRouSi();
        //在本类中,也可可以直接使用foodmenu调菜单
        //foodmenu.xiHongShiChaoJiDan();
        //foodmenu.yuXiangRouSi();
    }
}

//厨师---实现接口
    //中餐厨师-------继承过来的抽象方法要重写
class ChinaCooker implements  FoodMenu{
    public void  xiHongShiChaoJiDan(){
        System.out.println("中餐师傅做的西红柿炒鸡蛋");
    }

    public void  yuXiangRouSi(){
        System.out.println("中餐师傅做的鱼香肉丝");
    }

}
   //西餐厨师-------继承过来的抽象方法要重写
class AmericCooker implements FoodMenu{
    public void  xiHongShiChaoJiDan(){
        System.out.println("西餐师傅做的西红柿炒鸡蛋");
    }

    public void  yuXiangRouSi(){
        System.out.println("西餐师傅做的鱼香肉丝");
    }
}

🥅类和类之间的关系、抽象类和接口之间的区别

**❤️ is a(继承)、has a(关联)、like a(实现) **

** is a:**
Cat is a Animal(猫是一个动物)
凡是能够满足is a的表示“继承关系”
A extends B //A继承B

** has a:**
I has a Pen(我有一支笔),Pen就是I的属性
凡是能够满足has a关系的表示“关联关系”
关联关系通常以“属性”的形式存在。
A{
B b; //A中有B
}

** like a:**
Cooker like a FoodMenu(厨师像一个菜单一样)
凡是能够满足like a关系的表示“实现关系”
实现关系通常是:类实现接口。
A implements B //A实现B

❤️ 抽象类和接口之间的区别

1、抽象类是半抽象的;接口是完全抽象的。
2、抽象类中有构造方法;接口中没有构造方法(接口中只有常量和抽象方法)。
3、类和类之间只能单继承;接口和接口之间支持多继承。
4、一个类可以同时实现多个接口;一个抽象类只能继承一个类(单继承)。
5、接口中只允许出现常量和抽象方法。
以后接口使用的比抽象类多,一般抽象类使用的还是少;接口一般都是对“行为”的抽象。

标签: 开发语言 java

本文转载自: https://blog.csdn.net/m0_61933976/article/details/125131164
版权归原作者 @每天都要敲代码 所有, 如有侵权,请联系我们删除。

“深入理解面向对象(第一篇)”的评论:

还没有评论