面向对象

多态

• 多态即同一方法可以根据发动对象的不同而采用多种不同的行为方式
• 多态是方法的多态，属性没有多态
• 父类和子类的关系

存在的条件：

• 要有继承关系
• 子类重写父类方法
• 父类引用指向子类对象

无法重写

• static
• final
• private

instanceof

public class App {
    public static void main(String[] args) {
        Object object = new Student();
        /*
        System.out.println(x instanceof y);
        判断x和y是不是父子关系，看x所指向的实际类型是不是y的子类
         */
        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
    }
}

public class Student extends Person {
    
}

public class Teacher extends Person{

}

public class Person {
  
}

引用类型转换

public class App {
    public static void main(String[] args) {
       Person person = new Student();//Student转Person，低转高，可以直接转
        //将这个person对象转换为Student类型，我们就可以使用Student类型的方法了
        /*Student student = (Student) person;//Person类转换为Student类，高转低，需要强制转换
        student.go();
         */
        ((Student)person).go();
    }
}

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

    }
}

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

static

• 在属性方法中的应用

public class App {
    private static int age;
    private double score;
    public void run(){
       go();//非静态方法可以调用静态方法
    }
    public static void go(){//静态方法可以调用静态方法，不能调用非静态方法

    }
    public static void main(String[] args) {
        App a1 = new App();
        System.out.println(App.age);//加了static关键字的属性额可用类名.属性调用
        System.out.println(a1.score);
    }
}

• 在代码块中

public class Person {
    //2 第二个执行，匿名代码，不能主动调用，可以用来赋一些初始值
    {
        System.out.println("匿名代码块");
    }
    //1 最先执行，但只执行一次，静态代码块：该类一加载就执行
    static {
        System.out.println("静态代码快");
    }
    //3 第三个执行构造方法
    public Person() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person person = new Person();
    }
}

• 在静态导包时使用

import static java.lang.Math.random;//静态导入包
public class App {
    public static void main(String[] args) {
        System.out.println(random());//静态导入包后 可直接用
    }
}

抽象类

• abstract修饰符修饰的类就是抽象类，修饰的方法就是抽象方法
• 抽象类的所有方法必须由子类实现
• 特点：抽象类不能new，只能靠子类去实现，就是个约束
• 抽象类中也可以些普通方法，但抽象方法必须在抽象类中

//抽象类的所有方法，继承了它的子类都必须要实现它的方法，除非子类也是抽象类
public class Student extends Person{
    @Override//要继承抽象类，必须方法重写
    public void go() {

    }
}

//抽象类的所有方法必须由子类实现
public abstract class Person {//抽象类
    public abstract void go();//抽象方法，只有方法名，没有方法的实现
}

接口：本质是契约

• 普通类：只有具体的实现
• 抽象类：具体时限和规范（抽象方法）都有
• 接口：只有规范，专业的约束
• 声明类的关键词是class，声明接口的关键词是interface

接口的作用

• 进行约束
• 能定义一些方法，让不同的人实现
• 接口中方法默认类型public abstract，常量默认public static final
• implements可以实现多个接口，必须要重写接口中的方法

public interface UserService {//接口都需要有实现类
    //接口中的所有定义其实都是抽象的public
    void add(String name);//接口中的方法：返回值类型 方法名(参数);
    void delete(String name);//只有定义，没有具体的实现
    void update(String name);
    void query(String name);
}

public interface TimeService {
    void timeer();
}

//java是单继承，但可以利用接口实现多继承
public class UserServiceImpl implements UserService,TimeService{//实现类名一般在接口名后加Impl
    //要实现借口里的定义，必须要在实现类里重写方法
    @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 timeer() {

    }
}

原文：https://www.cnblogs.com/wpxz1005/p/15249575.html