2021.07.04

2021.07.04总结
instanceof 用来判断两个类的关系

package OOP.Dx06instanceof;
public class Student extends Person{
    public void go(){
        System.out.println("go");
    }
}
/*
public static void main(String[] args) {
        //Object>Person>Student  继承关系
        //Object>Person>Teacher
        //Object>String
        Object s1 = new Student();
        System.out.println(s1 instanceof Student);//true
        System.out.println(s1 instanceof Person);//true
        System.out.println(s1 instanceof Object);//true
        System.out.println(s1 instanceof Teacher);//false
        System.out.println(s1 instanceof String);//false

        Person s2 = new Student();
        System.out.println(s2 instanceof Student);//true
        System.out.println(s2 instanceof Person);//true
        System.out.println(s2 instanceof Object);//true
        System.out.println(s2 instanceof Teacher);//false
        //System.out.println(s2 instanceof String);//编译报错 此处Person和String属于同级

        Student s3 = new Student();
        System.out.println(s3 instanceof Student);//true
        System.out.println(s3 instanceof Person);//true
        System.out.println(s3 instanceof Object);//true
        //System.out.println(s3 instanceof Teacher);//编译报错 此处Student和Teacher同级
        //System.out.println(s2 instanceof String);//编译报错 此处Student和和String毫无关系

        //System.out.println(X instanceof Y);编译报错说明X和Y没有关系，结果为true表明Y和X的指向类型（上面的new Student）也有关系
    }*/
``
**关于类的强制转换**
```java
package OOP.Dx06instanceof;
public class Person {
    public void run(){
        System.out.println("run");
    }
}
/*
public static void main(String[] args) {
        //父类转换子类通过（子类）强转方法进行 强转后可以使用子类的一些方法
        //子类转换父类 可以直接转换（自动转换）可能会丢失一些自己独有的方法
        多态
        1.引用父类指向子类的对象
        2.把子类转换成父类 向上转型会自动转型
        3.把父类转换成子类 向下转型需要强制转换，会丢失部分方法
        4.方便方法的调用 减少重复代码 提高利用率 更加简洁
        抽象编程思想：封装 继承 多态 抽象性 接口
        多实践 持续学习 多测试自己的想法
    }*/

关于static
1.通过import static 静态导入的包 其中的方法可以直接调用`

package OOP.Dx07static;
//静态导入包
import static java.lang.Math.random;
import static java.lang.Math.PI;
public class Text {
    public static void main(String[] args) {
        System.out.println(random());
        System.out.println(PI);
        //静态导入包后可以直接调用
        //final 常量修饰符 修饰的类不能再被继承
    }
}

2.static修饰的静态变量静态方法和类同时加载，所以可以直接调用，非静态的变量和方法需要通过new方法才能使用

package OOP.Dx07static;
public class Student {
    private static int age;//静态变量 多线程常用
    private double score;//非静态变量
    public void run(){
    }
    public static void go(){
    }
    public static void main(String[] args) {
        Student s1 = new Student();
        System.out.println(Student.age);//静态可以直接调用
        System.out.println(s1.age);
       // System.out.println(Student.score); 非静态未加载不能直接调用，需要new加载一下
        System.out.println(s1.score);//new以后非静态的可以调用
        go();//静态方法也可以直接调用
        Student.go();
        s1.run();//new以后可以调用
    }
}

3.使用{}来写代码块，代码块只有代码没有名称
在一个类里先执行static修饰的静态的代码块，然后是代码块，最后是构造器（构造方法） 静态的代码块只执行一次

package OOP.Dx07static;
public class Person {
    {
        System.out.println("匿名代码块");
        //代码块（匿名代码块）只有代码没有名称  第二个输出  可以用来赋于初始值 和对象一起产生
    }
    static {
        System.out.println("静态代码块");
        //静态代码块 也是和类一起加载  第一个输出 最早执行 只执行一次
    }
    public Person() {
        System.out.println("构造方法");//第三个输出
    }
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println("+++++++++++++++++");
        Person person1 = new Person();
    }
    /*输出结果
    静态代码块
    匿名代码块
    构造方法
    +++++++++++++++++
    匿名代码块
    构造方法*/

抽象类
abstract 通过pubilc abstract定义一个抽象类，抽象类中可以有抽象方法也可以有普通方法，
抽象方法只提供约束，定义方法名，不提供方法实现
抽象方法所在的类必须是抽象类
抽象类只能被public修饰
抽象类中同样存在构造器（构造方法）

package OOP.Dx08抽象类;
//abstract 抽象类
public abstract class A {
    //抽象方法 只提供约束 不提供具体方法 只有方法的名字 没有方法的实现
    //接口可以多继承
    public abstract void did();
}
//抽象类不能new出来，只能靠子类实现他的约束
//抽象类可以有普通方法 抽象方法只存在于抽象类
//抽象类同样存在构造器
//抽象类是为了提高开发效率

package OOP.Dx08抽象类;
//继承抽象类 必须对抽象方法进行重写（父债子还）抽象类的所有方法继承了它的子类 除非子类也是抽象类 则需要子类的子类去重写
public class B extends A{
    @Override
    public void did() {

    }
}

接口

package OOP.Dx09接口;
//interface修饰代表接口 接口都需要有一个实现类
public interface UserService {
     int age=98;//接口中的常量都是静态的通过 public static final 修饰的，一般不在接口中定义常量
    void run();//接口默认都是public abstract修饰的
    void add(String name);
    void delete(String name);
    void updete(String name);
    void query(String name);
}
/*
接口的特点
1.java中接口是一些约束
2.定义一些方法，让不同的人通过不同的方法实现
3.接口不能被实例化，接口中没有构造器
4.可以通过implements实现多个接口（多继承）
5.必须要重写接口中的方法
 */

package OOP.Dx09接口;
public interface TimeService {
    void timer();
}

package OOP.Dx09接口;
//抽象类使用extends  只能单继承
//类 可以通过implements实现接口  多继承
//实现接口的类就需要重写接口中的方法
//Java中只有单继承 多继承需要通过接口实现
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void timer() {
    }
    @Override
    public void run() {
    }
    @Override
    public void add(String name) {
    }
    @Override
    public void delete(String name) {
    }
    @Override
    public void updete(String name) {
    }
    @Override
    public void query(String name) {
    }
}