面向对象3（Java）

• 即同一方法可以根据发送对象的不同而采用多种不同的行为方式
• 一个对象的实际类型是确定的，但是可以指向对象的引用类型可以很多
• 多态存在的条件：a.有继承关系；b.子类重写父类方法；c.父类引用指向子类对象
• 多态注意事项：
• 多态是方法的多态，属性没有多态
• 父类和子类，有联系 类型转换异常（ClassCastException）
• 存在条件：继承关系；子类重写父类方法；父类引用指向子类对象
• 还有三种方法不能重写：1.static方法（属于类，不属于实例）2.fianl方法（常量，不可改变）3.private方法（私有方法）

DuoTai.java

public class DuoTai {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型就不确定了
        //Student能调用的方法都是自己或者继承父类的
        Student s1 = new Student();
        //Person父类型，可以指向子类，但是不能调用子类的独有方法
        Person s2 = new Student();//父类的引用指向子类
        Object s3 = new Student();

        //对象能执行那些方法，主要看对象左边的类型，和右边关系不大
        s1.run();//当子类的方法为空时，子类调用的是父类的方法
        s2.run();//当子类重写了父类的方法时，父类调用的方法是子类的方法

        s1.son();
        //s2.son();
    }
}

父类：Person.java

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

子类：Student.java

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

    public void son(){
        System.out.println("son2");
    }
}

Instanceof关键字的作用

public class Instanceof {
    public static void main(String[] args) {
        //Object>String
        //Object>Person>Student
        //Object>Person>Teacher

        //System.out.println(x instanceof y);代表能不能通过

        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（Student和Teacher没有继承关系，属于平级，父类都是Person）
        System.out.println(object instanceof String);//false（Student和String没有继承关系）

        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);//编译报错(因为person和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);//编译报错(因为Student和Teacher没有关系)
        //System.out.println(student instanceof String);//编译报错(因为Student和String没有关系)
    }
}

父类：Person.java

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

子类：Student.java

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

    public void son(){
        System.out.println("son2");
    }
}

子类：Teacher.java

public class Teacher extends Person {

}

类型转换

• 父类引用指向子类的对象
• 把子类转换成父类，向上转换
• 把父类转换成子类，向下转换，强制转换
• 方便方法的调用，减少重复的代码，简介

public class LeiXing {
    public static void main(String[] args) {
        //类型之间的转换：父类    子类
        Student student=new Student();
        student.son();

        //子类转换成父类，可能会丢失自己本来的一些方法
        Person person=student;
        //person.son();(编译报错，无法使用son()方法了)

        //父类转换成子类，强制转换
        ((Student)person).son();//第一种方法

        Student person1= (Student) person;//第二种方法
        person1.son();
    }
}

static关键字详解

public class Static {
    private static int age;//静态属性
    private int score;//非静态属性

    public static void run(){//静态方法

    }
    public void go(){//非静态方法

    }

    public static void main(String[] args) {
        Static s1 = new Static();

        System.out.println(Static.age);//静态属性可以直接通过类名来调用
        //System.out.println(Static.score);//编译报错
        System.out.println(s1.score);//非静态属性则需要通过对象.属性来调用
        System.out.println(s1.age);//静态属也可以通过对象.属性来调用

        //方法和属性的性质相同
        run();
        Static.run();
        //Static.go();
        s1.go();
    }
}

public class Static2 {
    //第二执行（一般是用来赋初值）
    {
        System.out.println("匿名代码块");
    }
    //最先执行1（只执行一次）
    static {
        System.out.println("静态代码块");
    }
    //第三执行
    public Static2() {
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Static2 static2 = new Static2();
        System.out.println("=============");
        Static2 static3 = new Static2();
    }
}
运行结果：
静态代码块
匿名代码块
构造方法
=============
匿名代码块
构造方法

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

public class Static3 {
    public static void main(String[] args) {
        //System.out.println(Math.random());
        System.out.println(random());//可直接使用random方法
    }
}

抽象类

• abstract修饰符可以用来修饰方法也可以修饰类，如果修饰方法则该方法就是抽象方法，如果是修饰类则该类就是抽象类
• 抽象类中可以没有抽象方法，但是抽象方法的类必须是抽象类
• 抽象类，不能使用new关键字来创建对象，他是用来让子类继承的，没有构造器
• 抽象方法，只有方法声明，没有方法的实现，他是让子类实现的
• 子类继承抽象类，那么必须实现抽象类没有实现的抽象方法，否则该子类必须声明为抽象类
• 抽象为单继承，接口则可以多继承

//abstract抽象类
public abstract class Abstract {
    //约束，有人帮我们实现
    //抽象方法，只有方法声明，没有方法的实现
    public abstract void doSome();
}

public class Abs extends Abstract{
    //子类继承抽象类，那么必须实现抽象类没有实现的抽象方法，否则该子类必须声明为抽象类
    @Override
    public void doSome() {

    }
}

Original: https://www.cnblogs.com/TianCandy/p/16301337.html
Author: 糖果Tian
Title: 面向对象3（Java）