2021-.4-29抽象类和接口

笔记

抽象abstract

1抽象类关键字，修饰类和方法可以放在访问权限符public的前面或后面，一般放在后面

2抽象方法的个数没有限制，可以有也可以没有普通的方法

3抽象类必有抽象的方法，反抽象方法的一定的是抽象类

案例：

package Demo02;

public abstract class Door {
   public abstract void open();
   public abstract void close();
}

子类一

package edu.xcdq.Demo01;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 16:44
 */
public class KeypadDoor extends Door{

    public void open(){
        System.out.println("输入密码开门");
    }
    public void close(){
        System.out.println("轻轻关上");
    }

}

子类二

package edu.xcdq.Demo01;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 16:45
 */
public class PowerDoor extends Door{
    public void open(){
        System.out.println("遥控开门");
    }
    public void close(){
        System.out.println("遥控关门");
    }
}

测试

package edu.xcdq.Demo01;

import Demo02.Door;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 16:45
 */
public class Demo01 {
    public static void main(String[] args) {
        KeypadDoor keypadDoor = new KeypadDoor();
        keypadDoor.open();
        keypadDoor.close();


        PowerDoor powerDoor = new PowerDoor();
        powerDoor.close();
        powerDoor.open();
        Demo02.Door door = new Door() {
            @Override
            public void open() {
                System.out.println("临时实现开门");
            }

            @Override
            public void close() {
                System.out.println("临时实现关门");
            }
        };
        door.open();
        door.close();


    }
}

接口

1关键字interface，实现类的关键字implements

2接口中定义方法的声明，没有方法的方法体

3接口中的方法必须是公有的

package Demo03;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 17:31
 */
public interface Door {
    public void open();
    public void close();
}

package Demo03;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 17:33
 */
public class KeypadDoor implements Door{
    @Override
    public void close() {
        System.out.println("键盘开门");
    }

    @Override
    public void open() {
        System.out.println("键盘关门");
    }
}

package Demo03;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 17:32
 */
public class PowerDoor implements Door{
    @Override
    public void open() {
        System.out.println("开门");
    }

    @Override
    public void close() {
        System.out.println("关门");
    }
}

调用

package Demo03;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 17:43
 */
public class Demo03 {
    public static void main(String[] args) {
        KeypadDoor keypadDoor = new KeypadDoor();
        keypadDoor.open();
        keypadDoor.close();

        //可以用接口的类型  接受实现类创建的对象
        Door powerDoor = new PowerDoor();
        powerDoor.open();
        powerDoor.close();
    }
}

接口中的静态常量

由于接口是规范的，实现类必须包含其中的属性和方法，因此属性public static final原本的属性变成了静态常量

public interface Door {
    //接口的静态常量
    String desc = "是个门注意安全";
  //  public static final String desc = "是个门注意安全";
    public void open();
    public void close();
}

接口的两个例外

默认方法，只能通过实现类的对象调用keypadDoor.test01();

静态方法，只能通过接口名的方式调用Door.test02();

package Demo03;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 17:31
 */
//接口， 定义门的规范
public interface Door {
    //接口的静态常量
    String desc = "是个门注意安全";
  //  public static final String desc = "是个门注意安全";
    public void open();
    public void close();

    public default void test01(){
        System.out.println("接口中的静态方法");
    }
    public static void test02(){
        System.out.println("接口中的静态方法");
    }
}

keypadDoor.test01();
        Door.test02();

##总代码
#笔记

抽象abstract

1抽象类关键字，修饰类和方法可以放在访问权限符public的前面或后面，一般放在后面

2抽象方法的个数没有限制，可以有也可以没有普通的方法

3抽象类必有抽象的方法，反抽象方法的一定的是抽象类

案例：

package Demo02;

public abstract class Door {
   public abstract void open();
   public abstract void close();
}

子类一

package edu.xcdq.Demo01;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 16:44
 */
public class KeypadDoor extends Door{

    public void open(){
        System.out.println("输入密码开门");
    }
    public void close(){
        System.out.println("轻轻关上");
    }

}

子类二

package edu.xcdq.Demo01;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 16:45
 */
public class PowerDoor extends Door{
    public void open(){
        System.out.println("遥控开门");
    }
    public void close(){
        System.out.println("遥控关门");
    }
}

测试

package edu.xcdq.Demo01;

import Demo02.Door;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 16:45
 */
public class Demo01 {
    public static void main(String[] args) {
        KeypadDoor keypadDoor = new KeypadDoor();
        keypadDoor.open();
        keypadDoor.close();


        PowerDoor powerDoor = new PowerDoor();
        powerDoor.close();
        powerDoor.open();
        Demo02.Door door = new Door() {
            @Override
            public void open() {
                System.out.println("临时实现开门");
            }

            @Override
            public void close() {
                System.out.println("临时实现关门");
            }
        };
        door.open();
        door.close();


    }
}

接口

1关键字interface，实现类的关键字implements

2接口中定义方法的声明，没有方法的方法体

3接口中的方法必须是公有的

package Demo03;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 17:31
 */
public interface Door {
    public void open();
    public void close();
}

package Demo03;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 17:33
 */
public class KeypadDoor implements Door{
    @Override
    public void close() {
        System.out.println("键盘开门");
    }

    @Override
    public void open() {
        System.out.println("键盘关门");
    }
}

package Demo03;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 17:32
 */
public class PowerDoor implements Door{
    @Override
    public void open() {
        System.out.println("开门");
    }

    @Override
    public void close() {
        System.out.println("关门");
    }
}

调用

package Demo03;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 17:43
 */
public class Demo03 {
    public static void main(String[] args) {
        KeypadDoor keypadDoor = new KeypadDoor();
        keypadDoor.open();
        keypadDoor.close();

        //可以用接口的类型  接受实现类创建的对象
        Door powerDoor = new PowerDoor();
        powerDoor.open();
        powerDoor.close();
    }
}

接口中的静态常量

由于接口是规范的，实现类必须包含其中的属性和方法，因此属性public static final原本的属性变成了静态常量

public interface Door {
    //接口的静态常量
    String desc = "是个门注意安全";
  //  public static final String desc = "是个门注意安全";
    public void open();
    public void close();
}

接口的两个例外

默认方法，只能通过实现类的对象调用keypadDoor.test01();

静态方法，只能通过接口名的方式调用Door.test02();

package Demo03;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 17:31
 */
//接口， 定义门的规范
public interface Door {
    //接口的静态常量
    String desc = "是个门注意安全";
  //  public static final String desc = "是个门注意安全";
    public void open();
    public void close();

    public default void test01(){
        System.out.println("接口中的静态方法");
    }
    public static void test02(){
        System.out.println("接口中的静态方法");
    }
}

keypadDoor.test01();
Door.test02();
#总代码
##Demo01

package edu.xcdq.Demo01;

import Demo02.Door;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 16:45
 */
public class Demo01 {
    public static void main(String[] args) {
        KeypadDoor keypadDoor = new KeypadDoor();
        keypadDoor.open();
        keypadDoor.close();


        PowerDoor powerDoor = new PowerDoor();
        powerDoor.close();
        powerDoor.open();
        Demo02.Door door = new Door() {
            @Override
            public void open() {
                System.out.println("临时实现开门");
            }

            @Override
            public void close() {
                System.out.println("临时实现关门");
            }
        };
        door.open();
        door.close();


    }
}

##Door

package edu.xcdq.Demo01;

public class Door {
    public void Door(){
        System.out.println("开门");
    }
   public void close(){
       System.out.println("关门");
   }

}

KeypadDoor

package edu.xcdq.Demo01;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 16:44
 */
public class KeypadDoor extends Door{

    public void open(){
        System.out.println("输入密码开门");
    }
    public void close(){
        System.out.println("轻轻关上");
    }

}

##PowerDoor

package edu.xcdq.Demo01;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 16:45
 */
public class PowerDoor extends Door{
    public void open(){
        System.out.println("遥控开门");
    }
    public void close(){
        System.out.println("遥控关门");
    }
}

#Demo02.Demo.1

package Demo02;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 16:45
 */
public class Demo01 {
    public static void main(String[] args) {
        KeypadDoor keypadDoor = new KeypadDoor();
        keypadDoor.open();
        keypadDoor.close();

        PowerDoor powerDoor = new PowerDoor();
        powerDoor.close();
        powerDoor.open();


    }
}

##Door

package Demo02;

public abstract class Door {
   public abstract void open();
   public abstract void close();

   public void test(){
      System.out.println("可以有普通的方法");
   }
}

##KeypadDoor

package Demo02;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 16:44
 */
public class KeypadDoor extends Door {
    public void open(){
        System.out.println("");
    }
    public void close(){
        System.out.println("");
    }
}

##PowerDoor

package Demo02;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 16:45
 */
public class PowerDoor extends Door {
    public void open(){
        System.out.println("");
    }
    public void close(){
        System.out.println("");
    }
}

##Demo03.Demo01接口

package Demo03;

/**
* @qvthor liuwenzheng
* @date 2021/4/29 17:43
*/
public class Demo01 {
   public static void main(String[] args) {
       KeypadDoor keypadDoor = new KeypadDoor();
       keypadDoor.open();
       keypadDoor.close();

       //可以用接口的类型  接受实现类创建的对象
       Door powerDoor = new PowerDoor();
       powerDoor.open();
       powerDoor.close();

       keypadDoor.test01();
       Door.test02();
   }
}

##Door

package Demo03;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 17:31
 */
//接口， 定义门的规范
public interface Door {
    //接口的静态常量
    String desc = "是个门注意安全";
  //  public static final String desc = "是个门注意安全";
    public void open();
    public void close();

    public default void test01(){
        System.out.println("接口中的静态方法");
    }
    public static void test02(){
        System.out.println("接口中的静态方法");
    }
}

KeypadDoor

package Demo03;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 17:33
 */
public class KeypadDoor implements Door{
    @Override
    public void close() {
        System.out.println("键盘开门");
    }

    @Override
    public void open() {
        System.out.println("键盘关门");
    }
}

##PowerDoor

package Demo03;

/**
 * @qvthor liuwenzheng
 * @date 2021/4/29 17:32
 */
public class PowerDoor implements Door{
    @Override
    public void open() {
        System.out.println("开门");
    }

    @Override
    public void close() {
        System.out.println("关门");
    }
}