接口，类型转换，抽象类，接口

instanceof和类型转换

• instanceof（类型转换） 引用类型 ，判断一个对象是一个什么类型
• x instanceof y 能不能编译通过是看取决于x与y存不存在父子关系，x指向的类型与y有关系也能通过

package Demo6;

public class Application {
    public static void main(String[] args) {
        //Object>String
        //Object>Person>Teacher
        //object>Person>Student
        Object object = new Demo6.Student();
        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof String);//False
        System.out.println("====================");
        Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//false
       // System.out.println(person instanceof String);编译报错
        System.out.println("====================");
        Student student =new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
       // System.out.println(student instanceof Teacher);//false

    }
}

类型转换

1. 父类引用指向子类的对象

2. 子类的引用不能指向父类的对象

3. 把子类转换为父类：向上转型 自动转型 子类的独有方法会消失

4. 把父类转换为子类，向下转型 强制转换

5. 方便方法的调用：减少重复使用代码，简洁

   Application

package Demo6;

public class Application {
    public static void main(String[] args) {
//类型之间的转换， 基本类型的转换 高转低强制转换 低转高自动转换  64 32 16
        //类型之间的转换 父类（高） 子类（低）
        Person obj = new Student();
        //student 将这个类的对象转换为Student类型，我们就可以·用Student方法了
      //  Student student =(Student) obj;
       ((Student)obj).go();
       //z子类转父类，可能丢失一些自己本来的一些方法
       Student student = new Student();
       student.go();
       Person person = student;
       //person.go();//不能用   ：说明 //z子类转父类，可能丢失一些自己本来的一些方法
    }
}

Person

package Demo6;

import Demo5.Student;

public class Person {
  public void run(){
      System.out.println("son");
  }
    }

Teacher

package Demo6;

public class Teacher extends  Person{
}

Student

package Demo6;

public class Student extends Person {
    public void go(){

    }
}

package Demo7;

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();
    }
}

静态代码块
匿名代码块
构造方法
==============
匿名代码块
构造方法

---

---

package Demo7;
//静态导入包
import  static java.lang.Math.random;
import  static java.lang.Math.PI;
public class test {
    public static void main(String[] args) {
        System.out.println(Math.random());
        System.out.println(PI);
    }
}

• 类被final修饰就不能继承了

抽象类

• abstra修饰符可以用来修饰符方法也可以修饰类，如果修饰方法，那么该方法就是静态方法，如果修饰类，那么该类就是静态类
• 抽象类中可以没有抽象方法，但是抽象方法的类一定要声明抽象类
• 抽象方类，不能使用new关键字来创建对象，他是用来让子类继承的
• 抽象方法 ，只有方法的声明，没有方法的实现，他是用来让子类实现的
• 子类继承抽象类，那么就必须要实现抽象类没有实现的方法，否则该子类也要声明为抽象类

---

package Demo8;
//abstract 抽象类 ：类extends ：单继承~  （接口可以多继承）
public  abstract  class Action {
    //约束~有人帮我们实现
    //abstract 抽象方法 只有方法名字，没有方法实现
    public  abstract  void doSomething();
    //1.不能new这个抽象类只能靠子类去实现它：约束！
    //抽象类中可以写普通的方法
    //抽象方法必须在抽象中
    //抽象的抽象  约束：
    //思考 new，存在构造器吗？，存在的意义 抽象出来 提高开发效率
}

package Demo8;
//抽象类的所有方法，继承了他的子类都必须要实现他的方法，除非子类也是abstract抽象的，那么将由他的子子类实现
public class A extends  Action{
    @Override
    public void doSomething(){
}
}

接口

• 普通类：只有具体实现

• 抽象类 具体实现和规范（抽象方法）都有

• 接口：只有规范自己无法写方法~专业的约束 ，约束和实现分离：面向接口编程~

• 接口就是规范，定义的是一组规则，体现了现实世界中"如果你是…则必须能…"的意思。如果你是天使，则必须能飞，如果你是汽车，则必须能跑

• 接口的本质是锲约，像我们人间的法律一样，制定后大家遵守

• OO的精髓，是对象的抽象，最能体现这一点的是接口，为什么我们讨论设计 模式都只针对具备了抽象能力的语言比如java，c++等，就是因为设计模式所研究的，实际上就是如何去抽象

  ---

  ---

  声明类的关键字是class，声明接口的关键字是interface

package Demo9;
//interface 关键字 ，接口都有实现类
public interface Userservice {
    //接口中的所有定义都是抽象的public abstract
    void add(String name);
    void delete(String name);
    void updata(String name);
    void query(String name);
}

package Demo9;
//抽象类 ：extends
//类 可以实现接口implements 接口
//实现了接口的类，就需要重写接口中的方法
//利用接口实现多继承
public class UserserviceImpl implements Userservice,TimeService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void updata(String name) {

    }

    @Override
    public void query(String name) {

    }

    @Override
    public void timer() {

    }
}

package Demo9;
//interface 定义关键字 ，接口都需要实现类
public interface TimeService {
    void timer();
    //常量~ public static final
   public static final int age=99;
   int age1= 99;
}

接口的一些作用

1. 约束
2. 定义一些方法，让不同的认识实现 10（人） —> 1（接口）
3. 所有方法 public static
4. 静态常量 public static final
5. 接口不能被实例化~，接口中没有构造方法
6. implements可以实现多个接口
7. 必须要重写接口