面向对象

封装

alt+insert ：获取get、set方法

Ctrl+D：复制代码

一个类里面如果重写了有参构造函数，则无参构造就没有了，必须要自己定义一个无参构造函数。

继承

1. 子类继承父类，就会拥有父类的所有public方法。
2. Java中类只有单继承，没有多继承（即一个儿子只有一个爸爸，一个爸爸可以有多个儿子）。
3. extends是扩展，子类是父类的扩展。

public class Person{}

public class Student extends Person{}

public class Teacher extends Person{}

4. 在Java中，所有的类都默认直接或间接继承Object类。

super

1. 必须只能出现在子类的方法或构造方法中，只有在继承条件下可以使用，代表父类对象的应用。与this相反，this指本身调用者这个对象。

2. 子类Student、父类Person

   执行代码 Student student = new Student()时，先调用父类的无参构造函数，再调用子类的无参构造函数。

   注意：调用父类的构造器必须要在子类构造器的第一行

   public class Person {
       public Person() {
           System.out.println("Person无参执行");
       }
   }
   
   public class Student {
       public Student() {
           super(); //必须放在第一行，不写也可以，自动隐藏，默认无参构造
           System.out.println("Student无参执行");
       }
   }
   

3. super和this不能同时调用构造方法。
   this( ) 本类的构造
   super( ) 父类的构造

   public class Student {
       public Student() {
           super(); //此处代码会报错，无论super()和this()的顺序如何
           this();  //都会报错
           System.out.println("Student无参执行");
       }
   }
   

4. 如果父类没有无参构造函数，则子类若要定义无参构造函数的话，如下

   public class Person {
       public Person(String name) {
           System.out.println("Person无参执行");
       }
   }
      
   public class Student {
       public Student() {
           super("Lisa"); //必须放在第一行，必须要写
           System.out.println("Student无参执行");
       }
   }
   

重写Override

注：

1. 重写都是方法的重写，与属性无关。

2. 需要有继承关系，子类重写父类的方法。

3. 方法名必须相同，参数列表必须相同，方法体不同。

4. 修饰符：范围可以扩大但不能缩小： 若父类是private，则子类继承可以为public，反之不行。

   public > protected > default > private

5. 抛出的异常：范围可以被缩小但不能扩大：ClassNotFoundException （范围小）--> Exception（范围大）

A extends B
//test()函数为静态公用方法时
public static void test(){}

A a = new A();
a.test(); //输出A类里的test方法

B b = new A(); //父类的引用指向了子类
b.test();  //输出B类里的test方法

A extends B
//test()函数为非静态公用方法时
public void test(){}
//A类的test方法变成重写 @Override
A a = new A();
a.test(); //输出A类里的test方法

B b = new A(); //子类重写了父类的方法
b.test(); //仍然输出A类里的test方法

为什么需要重写：

1. 父类的功能，子类不一定需要，或者不一定满足。
2. alt+insert： @override

多态

注意：

1. 多态是方法的多态，属性没有多态。

2. 父类和子类要有联系 。类型转换异常：ClassCastException

3. 存在条件：继承关系，方法需要重写，父类引用指向子类对象 Father s = new Son();

4. 不能重写的方法：

   i. static方法，属于类 不属于实例

   ii.final 常量

   iii.private方法

public class Demo {
    public static void main(String []args) {
        //Student能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //父类的引用指向子类对象
        //Person 父类型，可以指向子类，但不能调用子类独有的
        Person s2 = new Student(); 
        Object s3 = new Student();
    }
}

instanceof

X instanceof Y

1. 看能不能编译通过，看X和Y有没有继承关系

2. true还是false，X所指向的子类型是不是Y的子类型

public class Demo {
    public static void main(String []args) {
        //Object > String
        //Object > Person > Teacher
        //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
        
        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);  //编译报错
        
        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); //编译报错
        System.out.println(student instanceof String);  //编译报错
    }
}

类型之间的转化：父 子

//父类转换为子类
//高                 低
Person obj = new Student();
//将这个对象obj转换为Student类型，我们就可以使用Student类型的独有方法了
//go方法在Student类里，不在Person类里
Student student = (Student)obj;
student.go();
//或：((Student)obj).go();

//子类转换为父类，可能丢失自己的本来的一些方法
Student student = new Student();
student.go();
Person person = student;

1. 父类引用指向子类的对象。
2. 把子类转换为父类，向上转型。
3. 把父类转换成子类，向下转型，强制转换，可能会丢失方法。
4. 方便方法的调用，减少重复的代码。

Static

public class Demo {
    private static int age; //静态变量
    private double score; //非静态变量
    public void run(){
      go();
    }
    public static void go(){
      //run();  //不可行
    }
    public static void main(String []args) {
      Demo d1 = new Demo();
      System.out.println(Demo.age);
      System.out.println(d1.score);
      System.out.println(d1.age);
      //System.out.println(Demo.score); //不可行
      
      new Demo().run();
      Demo.go();
      go();
      //run();  //不可行
    }
}

public class Demo {
    //在构造方法之前，赋初值
    {
      System.out.println("匿名代码块");
    }
    //只执行一次
    static{ 
      System.out.println("静态代码块");
    }
    public Demo(){
      System.out.println("构造方法");
    }
    public static void main(String []args) {
      Demo d1 = new Demo(); //输出结果顺序：
                            //静态代码块
                             //匿名代码块
                             //构造方法
      Demo d2 = new Demo(); //输出结果顺序：
                             //匿名代码块
                             //构造方法
      //静态代码块只执行一次
    }
}

//静态导入包
import static java.lang.Math.random

public class Demo {
    public static void main(String []args) {
      //加入静态导入包后 System.out.println(Math.random());
      System.out.println(random());
      System.out.println(PI);
    }
}

父类定义了final后，子类无法继承。【final是断子绝孙常量修饰符】

抽象类

用abstract修饰

public abstract class Demo {
    //abstract 抽象方法，只有方法名字，没有方法实现
    public abstract void doSomething();
    public void hello(){} //正常方法
}

//抽象类的所有方法，继承了它的子类，都必须要实现它的方法
//除非子类也是抽象类，则由子子类实现方法
public class A extends Demo {
    @Override
    public void doSomething(){}
}

抽象类的特点：

1. 不能new这个抽象类，只能靠子类去实现它：约束。
2. 抽象类：类 extends：单继承 （接口可以多继承）。
3. 抽象方法必须在抽象类中，但抽象类可以有普通方法。
4. 抽象的抽象：约束

接口

普通类：只有具体实现。

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

接口：只有规范，自己无法写方法，专业的约束，约束和实现分离。

接口的本质是契约

interface 定义关键字，接口都需要有实现类

public interface Demo {
    //常量定义 public static final
    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 Demo2 {
    void timer();
}

//抽象类：extends
//类可以实现接口 通过implements接口
//实现了接口的类，就需要重写接口中的方法
public class Demo implements Demo,Demo2{ //多继承
    @Override
    void add(String name){
      
    }
    @Override
    void delete(String name){
      
    }
    @Override
    void update(String name){
      
    }
    @Override
    void query(String name){
      
    }
    @Override
    void timer(){
      
    }
}

接口的作用

1. 约束
2. 定义一些方法，让不同的人实现
3. 方法 public abstract
4. 常量 public static final
5. 接口不能被实例化，因为接口中没有构造方法
6. implements 可以实现多个接口，多继承
7. 必须要重写接口中的方法

内部类

就是在一个类的内部再定义一个类

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); //若Inner类是static，则无法编译。因为静态先编译，然后是构造
                                //若Inner类是static，将id改为static类型即可编译
      }
    }
}

public class Test {
    public static void main(String []args) {
      Outer outer = new Outer();
      //通过外部类来实例化内部类
      outer.Inner inner = outer.new Inner();
      inner.in(); //输出“这是内部类的方法”
      inner.getID(); //输出 10
    }
}

public class Outer {
    
}
//这个类不能为public 一个Java类中可以有多个class类，但是只能有一个public class
class A{
  public static void main(String []args) {
      
    }
}

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