第四周:Day1

目录

---

---

1.多态的成员访问特点--孔子装爹

孔子:讲论语             孔子爹:讲JavaSE
​
有一天,孔子爹不在家,有人过来找孔子爹学习JavaSE,刚好孔子在家,孔子就开始装爹,讲JavaSE
​
伪代码:
class 孔子爹{
    int age = 40;
    public void teach(){
        System.out.println("讲解JavaSE");
    }
    }
    
class 孔子 exrend 孔子爹{
    int age = 20;
    public void teach(){
        System.out.println("讲解论语");
    }//特有功能
    public void playGame(){
        System.out.println("会玩王者");
}
    
    
//测试类
//父类引用指向子类对象
    孔子爹 k爹 = new 孔子;//向上转型
   
  System.out.println(k爹.age);//40---编译看左,运行看左
  k爹.teach();//讲论语----编译看左,运行看右
  k爹.playGame//运行不了,报错---子类的特有功能;
  孔子 k = (孔子)k爹;//向下转型,将父类的引用强转为子类的引用
  k.playGame();//访问自己本身的特有功能

2.多态的经典练习---台灯

设计一个台灯类(Lamp)其中台灯有灯泡类(Buble)这个属性，
还有开灯(on)这个方法。设计一个灯泡类(Buble)，
灯泡类有发亮的方法，其中有红灯泡类(RedBuble)和绿灯泡类(GreenBuble)
他们都继承灯泡类(Buble)一个发亮的方法，请设计出一段代码可以使台灯开启灯泡发亮
红灯泡发红光,绿灯泡发绿光!(多态)

//台灯类
public class Lamp {
    //台灯有灯泡类(Buble)这个属性
    private Buble buble;
    //开灯的方法
    public void on(Buble buble){//形式参数是一个灯泡类型
        buble.shine();//调用灯泡发亮的方法
    }
}

//灯泡类
public class Buble {
    //定义一个发亮的方法
    public void shine(){
        System.out.println("灯泡可以发亮了");
    }
}

//红灯泡
public class RedBuble extends Buble {
    @Override
    public void shine() {
        System.out.println("灯泡可以发红光了");
    }
}

//绿灯泡
public class GreenBuble extends Buble{
    @Override
    public void shine() {
        System.out.println("灯泡可以发绿光了");
    }
}

//测试类
public class Text {
    public static void main(String[] args) {
       //创建台灯类对象
       Lamp lamp = new Lamp();
       Buble buble = new RedBuble();
       //调用开灯方法
        lamp.on(buble);
        System.out.println("-------------");
        Buble buble1 = new GreenBuble();
        lamp.on(buble1);

        System.out.println("==============");
        //匿名对象
        lamp.on(new RedBuble());
        lamp.on(new GreenBuble());

    }
}

3.抽象类及注意事项

定义:如果一个类中,有抽象方法,那么这个类必须定义为抽象类
抽象方法:
    权限修饰符 abstract 返回值类型 方法名(参数列表)
抽象类本质:
    强制子类必须做的事情,重写抽象类的所有重写方法
抽象类的特点:
    抽象类不能实例化,不能创建对象
抽象类的注意事项:
    1.抽象类不能实例化,需要具体的子类实例化
    2.如果抽象类的子类是抽象类,也不能实例化,但一定会存在具体的子类,否则无异议
    3.抽象类的实例化,通过抽象类多态,父类引用子类对象,有具体的子类
    Fu fu = new Zi();其中Fu是一个抽象类类型;

3.1代码体现

//动物类
abstract  class Animal{//此时这个必须为抽象类

    //动物的吃---仅仅给出声明,没有方法体
    public abstract void eat();
    public abstract void sleep() ;//睡---应该定义抽象方法,让子类重写

    //非抽象方法
    public void method(){
        System.out.println("method Animal!");
    }
}

//定义一个子类
class Dog extends Animal{//在父类上--alt+enter--->选择implements methos  重写方法
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void sleep() {
        System.out.println("狗趴着睡觉");
    }

    //特有功能
    public void lookDoor(){
        System.out.println("狗看门");
    }

}

//测试类
public class AbstractDemo {
    public static void main(String[] args) {
        //创建Animal对象
       // Animal a = new Animal() ;

        //抽象类多态:父类引用指向子类对象  (现在父类是抽象类)
        Animal a = new Dog() ;
        a.eat() ;
        a.sleep();
        //向下转型
        Dog d = (Dog) a;
        d.lookDoor(); //特有功能
    }
}

4.抽象类的成员特点

1.成员变量:
    成员变量既可以是变量,也可以是自定义常量:被final修饰
2.成员方法:
    可以是抽象方法,也可以是非抽象方法
3.构造方法
    子类继承父类,存在继承关系,分层初始化
    先让父类初始化,然后子类再进行初始化

4.1抽象类的面试题

如果一个类中没有抽象方法,那么把这个类定义为抽象类的意义何在?
不能new,需要提供子类,提供代码的扩展性,最终肯定是有子类存在的;

5.灯泡问题的优化---抽象类

#### 

```java
//台灯类
public class Lamp {
    //台灯有灯泡类(Buble)这个属性
    private Buble buble;
    //开灯的方法
    public void on(Buble buble){//形式参数是一个灯泡类型
        buble.shine();//调用灯泡发亮的方法
    }
}
```

```java
//灯泡类
//应该将发亮的方法--->仅仅给出声明,让子类实现这个方法
public abstract class Buble {
 	public abstract void shine() ;//有抽象方法的类一定是抽象类
}
```

```java
//绿灯泡
public class GreenBuble extends Buble {


    @Override
    public void shine() {
        System.out.println("灯泡可以发绿光了");
    }
}

```

```java
//红灯泡
public class RedBuble extends Buble {


    @Override
    public void shine() {
        System.out.println("灯泡可以发红光了");
    }
}
```

```java
//测试类
public class Text {
    public static void main(String[] args) {
       //创建台灯类对象
       Lamp lamp = new Lamp();
       Buble buble = new RedBuble();
       //调用开灯方法
        lamp.on(buble);
        System.out.println("-------------");
        Buble buble1 = new GreenBuble();
        lamp.on(buble1);

        System.out.println("==============");
        //匿名对象
        lamp.on(new RedBuble());
        lamp.on(new GreenBuble());

    }
}

6. abstract不能和哪些关键字使用?

abstract的应用场景:修饰类或者成员方法
​
1.abstract不能和private关键字使用,因为被private修饰的只能在当前类访问,而加入abstract需要让子类实现这个方法;已经超出了当前访问的范围, 冲突!
​
2.abstract不能和final一块使用,因为被final修饰的成员方法不能被重写的,而abstract修饰的抽象方法需要让子类强制重写的,所以冲突!
​
3.abstract不能和static一块使用,因为被static修饰的方法,跟类相关的,随着类的加载而加载,而抽象方法需要被子类重写的,最终需要使用对象来抽象类多态:Fu fu   = new Zi() ;和static一块使用抽象方法在父类中又没有方法体,加载进行内存,没意义!

7.接口的定义格式

接口是一种规范,就是能够实现接口中的额外的功能,那么就说明当前这个事物局部这个功能!
宏观角度来说,就是体现事物能够实现的扩展的额外功能;
接口是比抽象类还抽象的一种类型;
接口的格式:
        关键字:interface 接口名{
        接口名和类名的命名规范是一致的----"大驼峰命名法"
        }
​
接口中的方法:
    只能是抽象方法,不能有方法体
接口特点:
    不能实例化,不能创建对象
接口的实例化:
    通过接口多态
接口的子实现类和接口的关系:
    implements实现关系
格式:
        interface 接口名{}
    class 子实现类名 implements 接口1,接口2...{}
    接口名 对象名 = new 子实现类名();
注意事项:
    如果当前接口子实现类是一个抽象类,一定会存在抽象类的子类,
    否则接口多态,子实现类new不了,所以当前抽象类一定有具体的子类!
    

8.接口中的成员特点

接口中的成员特点:
    成员变量只能是常量,存在默认修饰符 public static final :可以省略不写
接口中的构造方法:
    没有构造方法,只是提供一些抽象方法,让子实现类实现这些方法!
接口中的成员方法:
    只能是抽象方法(一般都是抽象方法),存在默认修饰符:public abstract :可以省略不写

8.1代码体现

//接口
interface Inter{
    //成员变量
    public static final int num = 20;
    int num2 = 100;
    //静态方法:跟接口,类相关的
    void show();
    public abstract void method();
}

/实际开发中,接口的子实现类名:接口名+Impl
class InterImp implements Inter{//子实现类是要实现接口中的抽象方法
    @Override
    public void show() {
        System.out.println("show.....");
    }

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

//测试类
public class InterfaceDemo1 {
    public static void main(String[] args) {
        //接口多态
       Inter inter = new InterImp();
        System.out.println(inter.num);
        System.out.println(inter.num2);
        inter.show();
        inter.method();
    }
}

9.接口和抽象类有什么区别

1.成员的区别:
​
    接口的成员:
    成员变量:只能是常量,存在默认的修饰符public static final,可以省略不写
    成员方法:一般的抽象方法,可以是default默认方法或者静态方法,必须有方法体;抽象方法,存在默认修饰符:public abstract 可以省略不写
    构造方法:没有
    
    抽象类的成员:
    成员变量:可以是常量(被final修饰),也可以是变量
    成员方法:既可以是抽象方法,也可以是非抽象方法;抽象方法中的abstract不能省略!
    构造方法:存在有参构造/无参构造都可以;因为还是继承关系,肯定分层初始化的!
    
2.关系的区别:
    
    类与类的关系:extends;类可能是抽象类或具体类;
            继承关系只支持单继承,不支持多继承,可以多层继承
    类与接口的关系:implements实现关系;一个类继承另一个,类的同时可以实现多个接口;
    接口与接口的关系:extends继承关系;可以单继承,可以多继承,也可以多层继承;
    
3.设计理念的区别:
​
    抽象类:最终体现的是具体的子类,是继承关系;
    接口:子实现类实现接口,是实现关系;