类型转换、static、接口和抽象类

一、instanceof关键字

主要用于判断A对象是否属于B类（父子类或者本类），没有关系的两个类会直接编译报错。

强制转换：如果子类转为父类会丢失掉属于自己的特殊方法，而父类转换为子类则需要强转

public class Person {
    public void run(){
        System.out.println("run");
    }
}
​
public class Student extends Person{
    public void go(){
        System.out.println("go");
    }
    /*
       //Object > Person >Student
        Object object = new 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 Teacher);//false
        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);//编译报错
     */
}    
public class Application {
​
    public static void main(String[] args) {
        //类型之间的转化 : 基本类型转化   高低64 32 16
        //高                 低
        //子类转换为父类，可能丢失自己本来的一些方法！
        Person obj = new Student();
​
        //obj 将这个对象转换为Student类型，我们就可以使用Student类型的方法了！
        ( (Student) obj).go();
​
    }
    /*
    1.父类的引用指向子类对象
    2.把子类转换为父类，向上转型；
    3.把父类转换为子类，向下转型，强制转换
    4.方便方法的调用，减少重复的代码，简洁
​
    抽象：封装、继承、抽象
     */
}    
    

二、static关键字

• static标识的变量和方法属于类，在类加载的时候就完成了，而普通的成员方法和变量在此时还没有加载完

• 所以被static所修饰的方法无法直接调用非静态的变量和方法

//static
public class Student {
    private static int age;//静态的变量  多线程
    private double score;//非静态的变量
​
    public void run(){
​
    }
    public static  void go(){
​
    }
//static标识的变量和方法属于类，在类加载的时候就完成了，而普通的成员方法和变量在此时还没有加载完
    public static void main(String[] args) {
        Student student = new Student();
​
        System.out.println(Student.age);
        System.out.println(student.age);
        System.out.println(student.score);
    }
}

• 代码块：执行顺序从上到下，比构造器要先执行

  • 静态代码块：被static修饰的代码块，只执行一次，也是在类加载的时候执行的

  • 代码块（匿名代码块）：一般用于赋初始值

public class Person {
​
    static{
        //静态代码块(加载初始化数据) 1.只执行一次
        System.out.println("静态代码块");
    }
​
    {
        //代码块(匿名代码块) 2.赋初始值
        System.out.println("匿名代码块");
    }
​
​
    //3.
    public Person() {
        System.out.println("构造方法");
    }
​
    public static void main(String[] args) {
        Person person = new Person();
    }
}

三、抽象类

• abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法，那么该方法就是抽象方法；如果修饰类，那么该类就是抽象类。

• 抽象类中可以没有抽象方法，但是有抽象方法的一定是抽象类

• 抽象类不能使用new关键字来创建对象，它是用来让子类继承的

• 抽象方法，只有方法的声明，没有方法的实现，它是用来让子类实现的

• 子类继承抽象类，那么就必须要实现抽象类没有实现的抽象方法，否则该子类也要声明为抽象类

//abstract 抽象类： 类 extends 单继承，没有办法继承多个类     接口可以多继承
public abstract class Action {
​
    //约束~有人帮我们实现~
    //abstract 抽象方法，只有方法名字，没有方法的实现！
    public abstract void doSomething();
​
    //1.不能new这个抽象类，只能靠子类去实现它：约束！
    //2.抽象类中可以写普通的方法
    //3.抽象方法必须在抽象类中
    //抽象的抽象：约束  提高开发效率
    public void run(){}
}
//抽象类的所有方法，继承了它的子类都必须要实现它的方法，除非子类也是抽象类
public class A extends Action{
    @Override
    public void doSomething() {
​
    }
}

注意点，虽然抽象类不能被创建，但是它有构造方法，他的存在有助于保存一个月数，提高开发效率。

---

四、接口

• 普通类：只有具体实现

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

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

• 接口就是规范，定义的是一组规则，体现了现实世界中"如果你是...则必须能..."的思想。如果你是阳光，就该暖和；如果你是宝石，就该闪耀。

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

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

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

• 接口的作用：

  • 约束

  • 定义一些方法，让不同的人实现

  • 方法都是public abstract修饰的

  • 常量都是public static final 修饰的

  • 接口不能被实例化，接口中没有构造方法

  • implements可以实现多个接口

  • 实现类必须要重写接口中的方法

//interface 定义的关键字，接口都需要有实现类
public interface UserService {
​
    //常量 public static final
    int AGE =99;
​
    //接口中的所有定义其实都是抽象的 public  abstract
    void add(String name);
    void delete(String name);
    void update(String name);
    void query(String name);
}
public interface TimeService {
    void timer();
}
//抽象类：extends
//一个类可以通过implements关键字实现接口
//实现了接口的类，就需要重写接口中的方法
// 多继承  利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{
    @Override
    public void add(String name) {
​
    }
​
    @Override
    public void delete(String name) {
​
    }
​
    @Override
    public void update(String name) {
​
    }
​
    @Override
    public void query(String name) {
​
    }
​
    @Override
    public void timer() {
​
    }
}

---

五、内部类

• 内部类就是在一个类的内部再定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。

• 分类：

  • 成员内部类

  public class Outer {
      private int id=10;
      public void out(){
          System.out.println("这是外部类的方法");
      }
  ​
     public class Inner{
          public void in(){
              System.out.println("这是内部类的方法");
          }
  ​
          //获得外部类私有的属性
          public void getId(){
              System.out.println(id);
          }
      }
  }
  public class Application {
  ​
      public static void main(String[] args) {
          Outer outer = new Outer();
          outer.out();
  ​
          Outer.Inner inner = outer.new Inner();
          inner.in();
          inner.getId();
  ​
      }
  }    

  • 静态内部类

  public class Outer {
      private int id=10;
      public void out(){
          System.out.println("这是外部类的方法");
      }
  ​
     public static class Inner{
          public void in(){
              System.out.println("这是内部类的方法");
          }
  ​
      }
  }

  • 局部内部类

  public class Outer {
  ​
  ​
      //局部内部类
      public void method(){
          class Inner{
              public void in(){
                  
              }
          }
      }
  }

  • 匿名内部类

public class Test {
    public static void main(String[] args) {
        //没有名字初始化类，不用将实例保存到变量中
        new Apple().eat();
        new UserService() {

            @Override
            public void hello() {

            }
        };

    }
}
class Apple{
    public void eat(){
        System.out.println("1");
    }
}

interface UserService{
    void hello();
}