10.abstract关键字、interface关键字、多态、static

今天的内容

1.abstract关键字（抽象类）

2.interface关键字（接口）

3.多态

4.static(静态的)

1.abstract关键字（抽象类）

1.1对于重写的讨论

父类的方法，子类可以继承使用。但是父类的方法不一定适用于子类。或者说父类不期望子类重写这个方法。

​ 但是目前的语法中，如果子类不重写父类的方法，是可以的，是不报错的。

​

期望有一种语法，要求子类必须重写【强制重写】

1.2abstract语法格式

abstract关键字修饰成员方法，是要求子类必须重写的，不然报错。

【注意事项】：

​ 1.abstract修饰成员方法之后，这个类也必须使用abstract进行修饰

​ 2.abstract修饰方法以后，不能有方法体。

​ 3.凡是使用abstract修饰的类叫抽象类。abstract方法叫抽象方法

​ 4.抽象类下面可以有非抽象方法。

​ 5.在子类中，只要是抽象方法，必须去实现（无条件的实现，不然报错)。

​ 6.抽象类（abstract）没有自己的类对象【重点】

​ 7.有抽象方法的类必须是抽象类。但是抽象类下面可以没有抽象方法

2.final关键字【重点】

final字面意思：

​ 最终的，终止的

fina可以修饰成员变量

​ 使用final修饰的成员变量，必须定义初始化的值，初始化以后不能被修改。

final修饰局部变量

​ 使用final修饰的一旦被赋值，就无法被修改

final修饰成员方法

​ final修饰的成员方法，子类不能被重写

final修饰类

​ final修饰的类的不能有自己的子类

​ String 类java给封装好的！！！

package com.qfedu.b_final;

final class TestFinal {
    final int num = 10;
    final  public void test() {
        System.out.println(num);
        //num = 20;
    }
}
//class Son extends TestFinal {
//   // public void test () {}
//}
public class Demo1 {
    public static void main(String[] args) {
        final int num;
        num = 10;
        //num = 20;

    }
}

3.interface关键字（接口）【重点！！！】

3.1生活中的接口

usb type-c 雷电口 插座？

作用！！！

扩展功能

3.2接口的语法

interface 接口的名字 {

​ 成员变量；

​ 成员方法；

}

【注意事项】：

​ 1.接口下面可以声明成员属性，但是这个属性是static 和final修饰的，省略了publicstatic final

​ 2.接口下面可以声明成员方法，但是方法必须是抽象的方法，省略了abstract

​ 3.jdk1.8新特性接口中允许使用default修饰方法。来完成对方法默认的定义。这个方法可以有方法体

​ 4.使用implements这个关键字取实现接口

回顾

抽象类
abstract 类名 {
	方法
}
方法：
	抽象方法
		public void test();没有方法体的方法
	非抽象方法
		public void test(){}
final：
	修饰成员变量，必须赋值
	修饰局部变量。不能被修改
	修饰成员方法。不能被重写
	修饰类。不能被继承。String fianl
接口
	扩展功能（多继承）
interface 接口名字 {
	抽象方法
}

4.多态（重要的！！！）

封装，继承，多态

父类的引用指向子类的对象。或者接口的引用指向接口实现类的对象

package com.qfedu.d_duotai;

interface USB{
    /**
     * 在USB接口中，定义了一个connect方法
     */
    public void connect();
}
class  Mouse implements USB{

    @Override
    public void connect() {
        System.out.println("鼠标设备连接电脑");
    }

}
class Logi extends Mouse {
    @Override
    public void connect() {
        System.out.println("罗技无线鼠标连接电脑");
    }
}

class Keybord implements USB {

    @Override
    public void connect() {
        System.out.println("键盘连接电脑");
    }
}
class IKBC extends Keybord{
    @Override
    public void connect() {
        System.out.println("IKBC  静音红轴 连接电脑");
    }
}
/*
* USB 接口  下面两个儿子 Mouse Keybord
* Mourse 有一个亲儿子 Logi
* Keybord 有一个亲儿子 IKBC
*
* */
class PC {
    public void usbConnect(USB usb) {
        usb.connect();
    }
}
public class Demo1 {
    public static void main(String[] args) {
        PC pc = new PC();
        Mouse mouse = new Mouse();
        pc.usbConnect(mouse);
        Logi logi1 = new Logi();
        pc.usbConnect(logi1);
    }
}

为什么要有多态

​ 多态的使用可以让方法的参数范围更加的灵活，范围更加广一点。可扩展性

java多态的条件：1.继承。2.重写3.父类的引用指向子类的对象 Animal tiger = new Tiger();

5.static关键字【重点！！！】

5.1static描述

static 静态

static 修饰的东西和对象无关

​ 1.通过对象使用静态修饰的东西是有隐患的或者直接报错

​

5.2static修饰成员变量

饮水机：

​ 1.公共区域

​ 2.你来学习之前他在

​ 3.走了之后还在

​ 4.共大家使用

给每个人都配一个饮水机

​ 开心？

​ 1.空间资源的浪费

​ 2.操作不太方便

​ 3.不安全

修饰成员属性的时候：

​ 类名.属性 ="";

【注意事项】:

​ 1.使用了static修饰了成员变量，有两种调用方式

​ 类对象.static修饰的静态的成员变量【ideal会提示有警告】

​ 类名.static修饰的静态的成员变量 ok以后记住这样用就行了

​ 2.在代码中没有创建任何类对象的话，可以通过类名直接调用static修饰的成员属性

​ 3.在代码运行过程中，已经销毁了所有的类对象。依然是可以通过类名调用静态的成员变量的

​ 4.static修饰的成员变量和对象一点关系都没有

​ 内存分析：

​ 只要是static修饰的员变量，都是在.class 类文件【加载阶段】，都会直接在内存的数据区。

创建对应的成员变量。该过程是早于创建对象。而且当前存在数据区的静态的成员变量是伴随咱们

整个程序运行阶段的。只要程序不退出，不销毁，他就会一直存在。

​ 保存区域：

​ 类对象保存在堆区，而静态的成员属性保存在数据区，这两个区域不相干的。

package com.qfedu.e_static;

class Person {
    //成员变量
    String name;
    int age;
    /*
    * 给与一个static修饰的变量
    * */
    static String country = "中华人民共和国";
    public Person () {


    }



}
public class Demo1 {
    public static void main(String[] args) {
        Person person = new Person();
        //person.name = "子鑫";
        System.out.println(person.country);//不是罪标准的写法，是有隐患的
        System.out.println(Person.country);//这个是最标准的写法
        Person.country = "china";
        /**/
        System.out.println(Person.country);
        System.out.println(person.country);

    }
}

5.3static修饰成员方法

public static 不要问

public static void main

静态成员方法的调用格式：

​ 1.通过类对象调用。但是不推荐

​ 2.通过类名调用。强烈推荐

【注意事项】：

​ 1.静态成员方法完全可以摆脱类对象的约束。静态的成员方法和类对象一点关系都没有

​ 静态成员方法是随着.class 进行加载到内存中的，已经在内存（代码区）中的完成定义。

​ 这个时候没有对象的创建，只要代码不退出或者销毁，静态成员方法一直会在代码区存在。，

​ 2.静态的成员方法中不能使用非静态的成员属性和非静态的成员方法

​ 3.静态的成员方法中不能使用this关键字。因为this表示是调用当前方法的类对象。

​ 静态方法是没有对象。是直接使用类名

​ 4.静态方法中可以创建对象。

​ 5.静态方法不能被重写

package com.qfedu.f_staticmethod;



class SingleDog {
    String name;
    int age;
    //静态的成员变量
    static int test = 20;
    public SingleDog () {

    }
    //成员方法
    public void eat () {
        System.out.println("甜蜜暴击");
    }
    //静态的成员方法
    public static void testStaticMethod () {
        System.out.println("静态的成员方法");
        //name = "狗蛋";
       //this.name = "年年红";
       // eat();

    }


}
/*
*
*
* */
public class Demo1 {
    public static void main(String[] args) {
        SingleDog.testStaticMethod();
//        SingleDog singleDog = new SingleDog();
//        singleDog.testStaticMethod();不推荐

    }
}

作业:

1.今天的代码至少三遍
		第一遍去抄可以
		第二遍想着敲，不会的看看
		第三遍自己敲
2.整理笔记特别是static,多态的，接口的，抽象类的面试题。手写到笔记本上。