Java微服务学习 第九天 接口 内部类

2.接口

当抽象类中所有方法都是抽象方法的时候，那么这个类是一个特殊的抽象类，叫接口 接口是java中最重要的概念，接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。 格式： interface 接口名{} 接口中的成员修饰符是固定的。 成员常量：public static final 成员函数：public abstract 发现接口中的成员都是public的。

public interface USB {
    public static final  int AGE=0;
    //public abstract void study1();//灰色的可以省略  方法名和常量名不能删
    default void add(){
        System.out.println("这是一个普通方法");
        study();
        eat();
        play();
    }
    void study();
    void eat();
    void play();
​
}
​

public class TestUsb implements USB {
​
    @Override
    public void study() {
        System.out.println("学习");
    }
​
    @Override
    public void eat() {
        System.out.println("吃饭");
    }
​
    @Override
    public void play() {
        System.out.println("打篮球");
    }
​
    public static void main(String[] args) {
        TestUsb testUsb = new TestUsb();
        testUsb.add();
​
    }

defalt来修饰：

接口的出现将“多继承”通过另一种方式体现出来，即“多实现”

接口的特点：

1.接口是对外暴露的原则

2.接口是程序的功能拓展

3.接口的出现降低耦合性 高内聚，低耦合

4.接口可以用来多实现

5.类与接口之间是实现关系，而且类可以继承一个类的同时还可以实现多个接口

6.接口与接口直接可以有继承关系

接口为类：com.zx.dao

借口实现包：com.zx.dao.impl

第三大特征 - 多态

什么是多态

简单来说，多态就是一个对象具有多种形态

向同一父类

instanceof 是 java的保留关键字

它的作用是测试它左边的对象是否是它右边的类的实例，返回boolean的数据类型

package com.zx.test1;
​
import com.zx.beans1.Animal;
import com.zx.beans1.Cat;
import com.zx.beans1.Dog;
​
public class AnimalTest {
    public static void main(String[] args) {
        Animal animal = new Dog();
       // animal.eat();
        Animal animal2 = new Cat();
        animal2.eat();
        
        if (animal instanceof Cat){
            Cat cat =(Cat) animal2;
        }else {
            System.out.println("类型不兼容");
        }
        if (animal instanceof Dog){
            Dog dog =(Dog) animal;
            animal.eat();
        }else {
            System.out.println("类型不兼容");
        }
​
    }
​
}

3.作业

第三题:分析以下需求，并用代码实现 1.定义动物类: 属性: 年龄行为: 喝水，吃东西(吃什么不确定) 2.定义游泳接口: 行为: 游泳方法 3.定义狗类: 行为: 吃饭(啃骨头)和游泳(狗刨) 4.定义羊类: 行为: 吃饭(羊啃草) 5.定义青蛙类: 行为: 吃饭(吃虫子)和游泳(蛙泳) 6.定义饲养员类: 行为: 饲养动物:包括吃饭和喝水 7.定义测试类: 创建饲养员对象,饲养员调用三次饲养方法:饲养狗,饲养羊,饲养青蛙

要求: 1子类重写父类中的吃东西方法 2.要求给狗和青蛙添加游泳的方法(实现游泳接口) 3.饲养员类中定义一个方法,传入动物类对象(父类)， 调用吃饭方法,如果有游泳方法也需进行测试 4.打印如下格式的结果: 喝水 狗啃骨头 狗会狗刨游泳 喝水 青蛙吃小虫青蛙会蛙泳 喝水 I 羊啃草

package com.动物题.beans;
​
public abstract class Animal {
    public void drink(){
        System.out.println("喝水");
    }
    public abstract void eat();
​
}
-----------------------------------------------------------------
package com.动物题.beans;
​
public class Dog   extends Animal  implements Swim{
​
    @Override
    public void eat() {
        System.out.println("狗啃骨头");
    }
​
    @Override
    public void swim() {
        System.out.println("狗会狗刨游泳");
    }
}
-----------------------------------------------------------------
package com.动物题.beans;
​
public class Frog extends Animal  implements Swim{
    @Override
    public void eat() {
        System.out.println("吃虫子");
    }
​
    @Override
    public void swim() {
        System.out.println("蛙泳");
    }
}
--------------------------------------------------------------------
package com.动物题.beans;
​
public class Person {
​
​
    public void feed(Animal animal) {
        animal.drink();
        animal.eat();
​
        if (animal instanceof Dog) {//
            Dog dog =(Dog) animal;
           dog.swim();
        }else if (animal instanceof Frog){
            ((Frog) animal).swim();
        }
    }
}
​
​
--------------------------------------------------------------------
package com.动物题.beans;
​
public class Sheep extends Animal {
    @Override
    public void eat() {
        System.out.println("羊啃草");
    }
}
--------------------------------------------------------------
package com.动物题.beans;
​
public interface Swim {
    void swim();
}
-----------------------------------------------------------------
package com.动物题.test;
​
import com.动物题.beans.Dog;
import com.动物题.beans.Frog;
import com.动物题.beans.Person;
import com.动物题.beans.Sheep;
​
public class Test {
    public static void main(String[] args) {
        Person person = new Person();
        Sheep sheep = new Sheep();
        Frog frog = new Frog();
        Dog dog = new Dog();
        person.feed(dog);
        person.feed(frog);
        person.feed(sheep);
​
​
​
    }
}
​

第四题：地上有一群鸟，一声枪响，有的吓得飞走了，有的吓得跑走了

提示：创建会飞的鸟的实体类FlyBird，创建会跑的鸟 的实体类RunBird，统一继承鸟类Bird 一声枪响（对鸟类下命令，执行run()，不同的子类执行不同的行为） 测试类中：创建鸟类数组，Bird[] birds = new Bird[20]; 利用随机数，依照不同的随机数实例化不同的子类，然后统一调用run方法执行

package com.zx.beans;
​
public interface Bird {
    void run();
​
​
}
---------------------------------------------------------------------
package com.zx.beans;
​
public class FlyBird implements Bird {
    @Override
    public void run() {
        System.out.println("鸟飞了");
    }
}
----------------------------------------------------------------------------
package com.zx.beans;
​
public class RunBird implements Bird {
    @Override
    public void run() {
        System.out.println("鸟跑了");
    }
}
----------------------------------------------------------------------------
package com.zx.test;
import java.util.Random;
import com.zx.beans.Bird;
import com.zx.beans.FlyBird;
import com.zx.beans.RunBird;
​
public class Test {
    public static void main(String[] args) {
        Bird[] birds = new Bird[20];
        Random r = new Random();
        FlyBird flyBird = new FlyBird();
        RunBird runBird = new RunBird();
        for (int i = 0; i <birds.length ; i++) {
            int number = r.nextInt(2);
​
            if (number==1){
                birds[i]=flyBird;
               // flyBird.run();
            }
            else {
                birds[i]=runBird;
                //runBird.run();
            }
            birds[i].run();
        }
    }
}
​

7.16、内部类

类的内部可以定义另一个类，如果在类Outer的内部再定义一个Inner，此时Inner称为内部类，Outer称为外部类。

1）成员内部类

可以使用修饰符修饰

Ⅰ、访问方法：

外部方法中创建内部类对象，调用内部类方法

外部类.内部类 内部类对象 = 外部类实例.内部类实例

package com.Mar.beans3;
​
public class Outer01 {
    private int age;
    public void out_method(){
        System.out.println("外部类方法");
        Inner inner = new Inner();  //创建内部类对象
        inner.in_method();
    }
    public class Inner{//内部类
        private int id;
        public void in_method(){
            System.out.println("内部类方法");
        }
    }
​
    public class Inner2{
​
    }
}
​
​
package com.Mar.test;
​
import com.Mar.beans3.Outer01;
​
public class OuterTest {
    public static void main(String[] args) {
        Outer01 outer01 = new Outer01();
        //outer01.out_method();
​
        //直接找内部类：外部类.内部类 内部类对象 = 外部类实例.内部类实例;
        Outer01.Inner outerIn01 = new Outer01().new Inner();
        outerIn01.in_method();
        Outer01.Inner outerIn02 = outer01.new  Inner();
        outerIn02.in_method();
    }
}
​

Ⅱ、变量调用

成员内部类中方法中的局部变量，调用外部类或内部类中重名的成员变量：

//方法中的局部变量:变量
//内部类中的成员变量:this.变量
//外部类中的成员变量:外部类类名.this.变量
​
package com.Mar.beans3;
​
public class Outer01 {
    private int age = 30;
    public void out_method(){
        System.out.println("外部类方法");
        Inner inner = new Inner();  //创建内部类对象
        inner.in_method();
    }
    public class Inner{//内部类
        private int id;
        private int age = 20;
        public void in_method(){
            int age = 30;
            System.out.println("内部类方法" + age + " " + this.age + " " + Outer01.this.age);
            //输出顺序：30 20 18
        }
    }
​
    public class Inner2{
​
    }
}
​

2）静态内部类

Ⅰ、访问方法：

package com.Mar.beans3;
​
public class Outer02 {
    private int id;
    public void out_method(){
        System.out.println("外部类方法");
    }
    public static class Inner02{
        public void in_method(){
            System.out.println("内部类方法");
        }
    }
}
​
package com.Mar.test;
​
import com.Mar.beans3.Outer02;
​
public class Outer02Test {
    public static void main(String[] args) {
        //外部类.内部类 内部类对象= new 外部类名称.内部类名称();
        Outer02.Inner02 inner02 = new Outer02.Inner02();
        inner02.in_method();
    }
}
​

3）方法内部类（认识）

package com.Mar.beans3;
​
public class Outer03 {
    private int id;
    
    public void out_method(){
        System.out.println("外部类方法");
        class Inner03{
            private int id;
            
            public void in_method(){
                System.out.println("内部类方法");
            }
        }
    }
}

4）匿名内部类