instanceof和类型转换

		//Object->Person->Student
        //Object->Person->Teacher
        //Object->String
        //高                 低
        Object obj = new Student();
		//System.out.println(x instanceof y);//能否编译成功却决于x和y是否具有父子关系
        System.out.println(obj instanceof Person);//true
        System.out.println(obj instanceof Student);//true
        System.out.println(obj instanceof Object);//true
        System.out.println(obj instanceof String);//false
        System.out.println(obj instanceof Teacher);//false
        System.out.println("=====================");
        Person person = new Student();
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Object);//true
        //System.out.println(person instanceof String);//编译报错！
        System.out.println(person instanceof Teacher);//false
        System.out.println("==========================");
        Student student = new Student();
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Object);//true
        //System.out.println(student instanceof String);//编译报错！
        //System.out.println(student instanceof Teacher);//编译报错！

类型之间的转化

        //高 ------------- 低（低转高不需要强制转换）
        Person person = new Student();
        //Student将这个对象转换为Student类型，就可以使用Student类型的方法了！
        //高转低需要强制转换
        //((Student)person).hello();
        Student student = (Student)person;
        student.hello();

        //子类转换为父类可能丢失自己本来的一些方法

static关键字

static静态的

静态变量

static int a = 3;

静态变量和非静态变量的区别是：静态变量被所有对象共享，且内存中只有一个副本，类初始加载时被初始化；非静态变量是对象所拥有的，创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。

静态方法

public static void run(){}

静态方法不依赖对象就可以访问，静态方法不能访问类的非静态成员变量和方法，因为非静态成员变量和方法必须依赖对象调用。非静态成员变量和方法可访问静态成员变量和方法。

静态代码块

static{
	int a= 3;
	int b = 4;
}

static代码块可以放在类中的任何地方，类中可以有多个static代码块，在类被初次加载，按照static的顺序执行每个static代码块，且只执行一次。可以优化程序性能。

静态导入包

import static java.lang.Math.random

import static java.lang.Math.PI

double a = random();

抽象类

abstract修饰符可以用来修饰方法也可以修饰类

抽象方法

public abstract void run();

抽象类

public abstract class Action{}

抽象类中可以没有抽象方法，但是又抽象方法的一定要声明为抽象类。

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

抽象方法只有方法的声明没有方法的实现，方法让子类来实现。

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

抽象类中存在构造方法

抽象类可以有构造方法,只是不能直接创建抽象类的实例对象而已。在继承了抽象类的子类中通过super()或super(参数列表)调用抽象类中的构造方法。

接口

普通类：只有具体实现

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

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

接口的本质是契约。

声明接口的关键字是interface

UserService.java

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

TimerService.java

public interface TimerService {
    void timer();
}

UserServiceImpl.java

//类 可以实现接口 implements 接口
//实现了接口的类就需要重写接口中的方法
//多继承，利用接口多继承
public class UserServiceImpl implements UserService,TimerService{
    @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类来说就是外部类。

• 1.成员内部类

  public class Outer {
      public static void main(String[] args) {
          Outer outer = new Outer();
          //通过外部类来实例化内部类
          Outer.Inner inner = outer.new Inner();
          inner.getId();
      }
      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);
          }
  
      }
  }
  //也是内部类
  class S{
  
  }
  

• 2.静态内部类

  public class Outer2 {
      public static void main(String[] args) {
          Outer2 outer = new Outer2();
  
      }
      private int id = 10;
      public void out(){
          System.out.println("这是外部类的方法！");
      }
  
      public static class Inner {
          public void in() {
              System.out.println("这是内部类的方法！");
          }
      }
  }
  

• 3.局部内部类

  public class Outer2 {
      public static void main(String[] args) {
          Outer2 outer = new Outer2();
  
      }
      private int id = 10;
      public void out(){
          System.out.println("这是外部类的方法！");
      }
  
      public static class Inner {
          public void in() {
              System.out.println("这是内部类的方法！");
          }
      }
  
      //局部内部类
      public void method(){
          //方法中也可以写内部类
          class V{
              public void v(){}
          }
      }
  }
  

• 4.匿名内部类

  public class Test {
      public static void main(String[] args) {
          //没有名字去初始化类,不用将实例保存到变量中
          new Apple().eat();
          //匿名内部类
          PersonService personService = new PersonService() {
  
              @Override
              public void hello() {
                  System.out.println("hello");
              }
          };
      }
  }
  class Apple{
      public void eat(){
          System.out.println("吃个苹果！");
      }
  }
  interface PersonService{
      void hello();
  }