java接口字段转义注解 java接口与实现类转换

首先应该了解接口是一个引用的数据类型它的本质是class。

接口怎么定义?

public interface 接口名称{
//接口的内容
}

接口不能直接创建对象，如果需要一个接口，那么需要创建一个实现类(类似于一个子类)

得出结论:类于接口之间的关系是实现关系

public class 实现类名称 implements 接口名称{
//覆盖重写父接口的所有抽象方法
}

练习题一：

1. 定义接口A，普通类B实现接口A

  2. A接口中，定义抽象方法showA。

3. A接口中，定义默认方法showB。

4. B类中，重写showA方法

5. 测试类中，创建B类对象，调用showA方法，showB方法

控制台效果如图所示:

//建立接口A

package com.Liaodai.demo01.demo1.demo04;

/**
 * @Author liaodaijiayue
 * @Date 2022/4/7 22:47
 * @Version 1.0
 */
public interface A {
    public abstract void showA();//此为抽象方法showA
    public abstract void showB();//此为抽象方法showB
}

 //B类

package com.Liaodai.demo01.demo1.demo04;

/**
 * @Author liaodaijiayue
 * @Date 2022/4/7 22:53
 * @Version 1.0
 */
public class B implements A{
    @Override
    public void showA() {
        System.out.println("AAAAA");//根据题意输出AAAAA
    }

    @Override
    public void showB() {
        System.out.println("BBBBB");//根据题意输出BBBBB

    }
}

//测试类中创建B类对象，调用showA方法，showB方法

package com.Liaodai.demo01.demo1.demo04;

/**
 * @Author liaodaijiayue
 * @Date 2022/4/7 22:55
 * @Version 1.0
 */
public class Text01 {
    public static void main(String[] args) {
        B b = new B();
        b.showA();
        b.showB();
    }
}

//控制台输出结果

练习题二:

1. 定义接口A，普通类B实现接口A。

  2. A接口中，定义抽象方法showA。

  3. A接口中，定义私有方法show10（String str），循环打印10次str。

  4. A接口中，定义默认方法showB10，showC10，分别调用show10方法，传入参数。

  5. 测试类中，创建B对象，调用showA方法，showB10方法，showC10方法

要求控制台效果如图所示:

//根据题意创建A接口:

package com.Liaodai.demo01.demo1.demo2;/**
 * @Author liaodaijiayue
 * @Date 2022/4/7 19:59
 * @Version 1.0
 */
public interface A {
   public abstract void showA();
   private void show10(String str){
       for (int i = 0; i <10; i++) {
           System.out.print(str+" ");
       }
       System.out.println();
   }
   public default void showB10(){
       show10("BBBBB");
   }
   public default void showC10(){
       show10("CCCCC");
   }
}

//创建B类对象

package com.Liaodai.demo01.demo1.demo2;/**
 * @Author liaodaijiayue
 * @Date 2022/4/7 20:02
 * @Version 1.0
 */
public class B implements A{

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

//测试类

package com.Liaodai.demo01.demo1.demo2;/**
 * @Author liaodaijiayue
 * @Date 2022/4/7 20:09
 * @Version 1.0
 */
public class Text02 {
    public static void main(String[] args) {
        B b = new B();
        b.showA();
        b.showB10();
        b.showC10();
    }
}

//控制台输出结果

 

练习题三:

1. 定义接口A，普通类B实现接口A。

2. A接口中，定义抽象方法showA。

3. A接口中，定义私有静态方法show10（String str），循环打印10次str。

4. A接口中，定义静态方法showB10，showC10，分别调用show10方法，传入参数。

5. B类中，定义静态方法showD

6. 测试类中，使用A接口，调用静态showB10方法，showC10方法，

7. 测试类中，使用B类，调用showA方法，showD方法。

要求控制太输出如下图所示:

//定义接口A

package com.Liaodai.demo01.demo1.demo2;import java.sql.SQLOutput;

/**
 * @Author liaodaijiayue
 * @Date 2022/4/7 20:27
 * @Version 1.0
 */

public interface A1 {
    public abstract void showA();
    private static void show10(String str){
        for (int i = 0; i < 10; i++) {
            System.out.print(str+" ");
        }
        System.out.println();
    }
    public static void showB10(){
        System.out.println("static BBBB");
        show10("BBBB");
    }
    public static void showC10(){
        System.out.println("static CCCC");
        show10("CCCC");
    }

}

//定义B类

package com.Liaodai.demo01.demo1.demo2;/**
 * @Author liaodaijiayue
 * @Date 2022/4/7 20:31
 * @Version 1.0
 */
public class B1 implements A1{
    @Override
    public void showA() {
        System.out.println("AAA");//覆盖重写父接口中的抽象方法
    }
    public static void showD(){//定义静态方法
        System.out.println("DDDD");
    }
}

//测试类

package com.Liaodai.demo01.demo1.demo2;/**
 * @Author liaodaijiayue
 * @Date 2022/4/7 20:33
 * @Version 1.0
 */
public class Text03 {
    public static void main(String[] args) {
        A1.showB10();
        A1.showC10();
        B1 b1 = new B1();
        b1.showA();
        B1.showD();
    }
}

//控制台输出结果

 

练习题四:

1. 定义接口Universe，提供抽象方法doAnything。

  2. 定义普通类Star，提供成员发光方法

  3. 定义普通类Sun，继承Star类，实现Universe接口

  4. 测试类中，创建Star对象，调用shine方法

  5. 测试类中，多态的方式创建Sun对象，调用doAnything方法，向下转型，调用shine方法。

要求控制台输出如下图所示:

//定义接口Universe

package com.Liaodai.demo01.demo1.demo2;/**
 * @Author liaodaijiayue
 * @Date 2022/4/7 20:42
 * @Version 1.0
 */
public interface Universe {
    public abstract void doAnything();//抽象类
}
 
// 定义普通类Star，提供成员发光方法package com.Liaodai.demo01.demo1.demo2;
/**
 * @Author liaodaijiayue
 * @Date 2022/4/7 20:44
 * @Version 1.0
 */
    public class Star {
    public void shine(){
        System.out.println("star:一闪一闪亮晶晶");
    }
}

定义普通类Sun，继承Star类，实现Universe接口

package com.Liaodai.demo01.demo1.demo2;/**
 * @Author liaodaijiayue
 * @Date 2022/4/7 20:45
 * @Version 1.0
 */
public class Sun extends Star implements Universe {
    @Override
    public void doAnything() {
        System.out.println("sun:太阳吸引着九大形象旋转");
    }
    @Override
    public void shine() {
        System.out.println("sun:光照八分钟到达地球");
    }
}

//测试类

package com.Liaodai.demo01.demo1.demo2;/**
 * @Author liaodaijiayue
 * @Date 2022/4/7 20:51
 * @Version 1.0
 */
public class Text04 {
    public static void main(String[] args) {
        Star star = new Star();
        star.shine();
        System.out.println("======================");
        Universe universe = new Sun();
        universe.doAnything();
        Sun sun=(Sun)universe;//实现多态的向下转型
        sun.shine();
    }
}

测试结果

向下转型:父类类型向子类类型向下转换的过程，这个过程是强制的。

向上转型:多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。当父类引用指向一个子类对象时，便是向上转型。

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子  类特有的方法，必须做向下转型。