Java学习之面向对象三大特征

继承

作用

实现

示例

instanceof 运算符

示例

要点

方法的重写(Override)

三个要点

示例

final关键字

作用

继承和组合

重载和重写的区别

Object类详解

基本特性

补充：IDEA部分快捷键

"= ="和equals()方法

示例

Super关键字

示例

继承树追溯

示例

封装(encapsulation)

优点

实现-使用访问控制符

示例（属性与方法同适用）

简单规则

多态(polymorphism)

要点

示例

对象的转型(casting)

示例

继承

作用

代码复用，更容易实现类的扩展
方便建模

实现

extends ---扩展。子类是父类的扩展。

示例

package inheritLearn;

import com.sun.org.apache.xerces.internal.impl.xpath.XPath;

import java.sql.PreparedStatement;

public class extendsTest {
    public static void main(String[] args) {
        Student a = new Student("张三",180.6,"java");
        a.rest();
        a.learn();
    }

    static class Person{
        String name;
        double height;

        public void rest(){
           System.out.println("you should rest!");
        }
    }

    static class Student extends Person{
        String major;
        public void learn(){
           System.out.println("It's learn time.");
           rest(); // 调用的Person的rest()
           System.out.println(name); // 这里的name是继承的Person类里面的name
        }

        public Student(String name,double height,String major){
           this.name = name;
           this.height = height;
           this.major = major;
        }

    }
    static class family extends Person{
        int num;
    }
}

instanceof 运算符

二元运算符，左边是对象，右边是类；当对象是右面类或子类所创建对象时，返回true，否则返回false

示例

public class extendsTest {
    public static void main(String[] args) {
        Student a = new Student("张三",180.6,"java");
        a.rest();
        a.learn();
        System.out.println(a instanceof Student);  // true
        System.out.println(a instanceof Person);   // true
    }

要点

父类也称超类、基类。子类：派生类等
Java中只有单继承，没有多继承。
Java中类美誉哦多继承，接口有多继承
子类继承父类，可以得到父类的全部属性和方法(除了父类的构造方法)，但不是可以直接访问(eg：父类私有的属性/方法)
定义一个类时，没有调用extends，则它的父类是：java.lang.Object

方法的重写(Override)

与overload(重载)完全无关

子类重写父类的方法，可用自身行为替换父类行为。重写是实现多态的必要条件。

三个要点

"=="：方法名、形参列表相同
"<="：返回值类型和声明异常类型，子类小于等于父类
">="：访问权限，子类大于等于父类

示例

package inheritLearn;

public class TestOverride {
    public static void main(String[] args) {
      Horse h = new Horse();
      Plane p = new Plane();
      h.run();
      h.getVehicle();
      p.run();
    }
}
class Vehicle{
    public void run(){
      System.out.println("跑起来");
    }
    public void getVehicle(){
      System.out.println("获得一个交通工具");
      }
}
class Horse extends Vehicle{
    @Override   // 可有可无，注解
    public void run(){
      System.out.println("dededededede~~~");  // 会覆盖掉上面的run()
    }
}
class Plane extends  Vehicle{
    @Override
    public void run() {
      System.out.println("wuwuwuwuwuwu~~~");  // 调用的自己的run(),非父类的run()
    }
}

final关键字

作用

修饰变量：被final修饰的变量不可改变，一旦赋了初值，就不能被重新赋值；eg：final int maxSize = 20；
该类方法不可被重写，但可以被重载；eg：final void study{}
修饰的类不能被继承，eg：Math、String； final class A{}

继承和组合

除了继承，组合也能实现代码复用。核心是：将父类对象作为子类的属性

package inheritLearn;

public class TestComponent {
    public static void main(String[] args) {
        Person p1 = new Person();
        p1.rest();
        Student s1 = new Student();
        s1.learn();
    }
}
class Person{
    String name;
    double height;

    public void rest(){
        System.out.println("you should rest!");
    }
}

class Student {
    String major;
    Person p = new Person();

    public Student() {

    }

    public void learn(){
        System.out.println("It's learn time.");
        p.rest();
        System.out.println(p.name);
    }

    public Student(String name,double height,String major){
        p.name = name;
        p.height = height;
        this.major = major;
    }

}

组合比较灵活，继承只能有一个父类，但是组合可有多个属性。

对于"is a"建议使用继承，"has a"建议使用组合

重载和重写的区别

重写：完全不同，子类重写父类的方法，可用自身行为替换父类行为。重写是实现多态的必要条件。
重载：一个类中可以定义多个名称相同，但形式参数列表不同的方法。注：重载的方法，实际上是完全不同的方法，只是名称相同

Object类详解

所有类都是Object类的子类，也具备Object类的所有特性。

基本特性

Object类是所有类的父类，所有的Java对象都拥有Object类的属性和方法
如果在类的声明中未使用extends，则默认继承Object类

public class TestObject extends Object{}
// 等价于:
public class TestObject{}

补充：IDEA部分快捷键

类的结构视图： alt + 7
看类的源码：ctrl + 左键
自动生成构造器、get、set方法、equals等：alt + insert(+ fn )
查看错误：alt + enter
快捷键输出常见字符串：
- main ： public static void main[String[] args]{}
- sout ： System.out.println();
- soutm ：System.out.println("描述：所在类中的，所有方法");

"= ="和equals()方法

"==" 代表比较双方是否相同，如果是基本类型则表示值相等，如果是引用类型则表示地址相等即是同一个对象
equals() 提供定义"对象内容相等"的逻辑，默认比较两个对象的hashcode(可理解成地址)，可根据自己的要求重写equals方法

示例

package inheritLearn;

import javax.sound.midi.Soundbank;
import java.util.Objects;

public class TestObject extends Object{

    int id;
    String name;
    String pwd;

    public TestObject(int id,String name,String pwd){
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public TestObject() {
    }

//    @Override
//    public String toString() {
//      return "账户名: " + name + "密码: " + pwd;
//    }

    public static void main(String[] args) {
        TestObject t = new TestObject();
        System.out.println(t.toString());
        TestObject t2 = new TestObject();
        System.out.println(t2.toString());
        TestObject t3 = new TestObject(1,"张三","456879");
        TestObject t4 = new TestObject(2,"李四","123456");
        System.out.println(t3.toString());
        System.out.println(t4.toString());
        System.out.println(t3.equals(t4));   // false
        TestObject t5 = new TestObject(2,"李四","123456");
        System.out.println(t4.equals(t5));   // 重写前：false（对象不一样） 重写后：只比较id，返回 ：true(id值一样)


    }

    // 重写equals()方法
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;  // 等于空或是类型不一样
        TestObject that = (TestObject) o;
        return id == that.id;
    }

//    @Override
//    public int hashCode() {
//      return Objects.hash(id, name, pwd);
//    }   // 通常重写equals的时候都需要重写hashCode()
}

Super关键字

"可以看作"是直接父类对象的引用，可通过super来访问父类中被子类覆盖的方法或属性。
使用super调用普通方法，语句没有位置限制，可在子类中随便调用
在一个类中，若是构造方法的第一行没有调用super(...)或(this...) ；那么Java默认都会调用super()，含义是调用父类的无参数构造方法

示例

package inheritLearn;

public class TestSuper {
    public static void main(String[] args) {
        new ChildClass().f();
    }
}
class FatherClass{
    public int value;
    public void f(){
        value = 56;
        System.out.println("FatherClass.value = " + value); // 56
    }
}

class ChildClass extends FatherClass{
    public int value;
    public int age;
    public void f(){
        super.f(); // 调用了父类的普通方法
        value = 33;
        System.out.println("ChildClass.value = " + value);  // 33
        System.out.println(value);  // 33
        System.out.println(super.value); // 56
    }
}

继承树追溯

属性/方法查找顺序(eg：查找变量h)
- 查找当前类中有无属性h
- 一次上溯每个父类，查看每个父类中是否有h，知道Object
- 如果未找到，则出现编译错误
- 上面步骤，只要找到h变量，则这个过程终止
构造方法调用顺序：
- 构造方法第一句总是：super(...)来调用父类对应的构造方法。所以，流程就是：先向上追溯到Object，然后再依次向下执行类的初始化块和构造方法，直到当前子类为止

注：静态初始化块调用顺序，与构造方法调用顺序一致，不再重复

示例

package inheritLearn;

public class TestSuper01 {
    public static void main(String[] args) {
//      System.out.println("开始创建第一个ChildClass对象...");
        new ChildClass01();
    }
}
class FatherClass01{
    public FatherClass01(){
        System.out.println("创建FatherClass01...");
    }
}
class ChildClass01 extends FatherClass01{
    public ChildClass01(){
        System.out.println("创建ChildClass01...");
    }
}

虽然调用的是子类：new ChildClass01() ;，但执行结果是先调用父类，再调用子类

package inheritLearn;

public class TestSuper01 {
    public static void main(String[] args) {
//      System.out.println("开始创建第一个ChildClass对象...");
        new ChildClass01();
    }
}
class FatherClass01{

    static {
        System.out.println("静态初始化：FatherClass01...");
    }
    public FatherClass01(){
        System.out.println("创建FatherClass01...");
    }
}
class ChildClass01 extends FatherClass01{
    static {
        System.out.println("静态初始化：ChildClass01...");
    }
    public ChildClass01(){
        System.out.println("创建ChildClass01...");
    }
}

封装(encapsulation)

高内聚、低耦合

优点

提高代码的安全性
提高代码的复用性
"高内聚"：封装细节，便于修改内部代码，提高可维护性
"低耦合"：简化外部调用，便于调用者使用，便于扩展和协作

实现-使用访问控制符

访问权限修饰符
修饰符	同一个类	同一个包中	子类	所有类
private(类内友好)	🤍
default(包内友好)	🤍	🤍
protected(父子友好)	🤍	🤍	🤍
public(全局友好)	🤍	🤍	🤍	🤍

示例（属性与方法同适用）

Test01：
package fengzhuangLearn;

public class Test01 {
    private     int testPrivate;
                int testDefault;
    protected   int testProtected;
    public      int testPublic;

    public void test(){
        System.out.println(this.testPrivate);
    }
}

Test02：
   // 同包
public class Test02 {

    public void paly(){
      Test01 p = new Test01();

      System.out.println(p.testDefault);
      System.out.println(p.testProtected);
      System.out.println(p.testPublic);
     // System.out.println(p.testPrivate);无法访问

    }
}

Test03：
// 同包且继承
public class Test03 extends Test01{
    public void learn(){
      System.out.println(super.testDefault);
      System.out.println(super.testProtected);
      System.out.println(super.testPublic);
    }
}

Test04：
// 不同包但继承
public class Test04 extends Test01 {
    public void sing(){
      System.out.println(super.testProtected);
      System.out.println(super.testPublic);
//    System.out.println(super.testPrivate); // 无法访问
//    System.out.println(super.testDefault); // 无法访问
      
      Test01 t = new Test01(); // 父类对象
      System.out.println(t.testPublic);
//    System.out.println(super.testProtected);// 无法访问 
//    System.out.println(super.testPrivate); // 无法访问
//    System.out.println(super.testDefault); // 无法访问
    }
}

关于protected的两个细节：

若父类和子类在同一个包中，子类可访问父类的protected成员，也可访问父类对象的protected成员
若子类和父类不在同一个包中，子类可访问父类的protected成员，不能访问父类对象的protected成员

简单规则

属性一般使用private访问权限
- 属性私有后，提供的相应get/set方法来访问相关属性，这些方法通常是public修饰的，以提供对属性的赋值与读取操作(boolean变量的get方法是is开头的)
方法：一些只用于本类的辅助性方法可以用private修饰，希望其他类调用的方法用public修饰

package fengzhuangLearn;

public class setTest {

    public void printTest(){
        System.out.println(name);
        System.out.println(id);
        System.out.println(sexy);
    }
    private int id;
    private String name;
    private boolean sexy;

    public int getId(){
        return id;
    }
    public void setId(int id){
        this.id = id;
    }

    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }

    public boolean isSexy(){
        return sexy;
    }
    public boolean setSexy(boolean sexy){
        this.sexy = sexy;
        return sexy;
    }
}

public class Test {
    public static void main(String[] args) {
        setTest t = new setTest();
        t.setId(100);
        t.setName("张三");
        t.setSexy(true);

        System.out.println(t.getId());
        System.out.println(t.getName());
        System.out.println(t.isSexy());

    }
}

多态(polymorphism)

同一个方法调用，不同对象行为完全不同

要点

方法的多态，不是属性的多态(多态与属性无关)
存在的3个必要条件：继承，方法重写，父类引用指向子类对象
父类引用指向子类对象后，用该父类引用调用子类重写方法，多态就出现了

示例

public class Animal {
    public void shout(){
        System.out.println("不允许狗叫");
    }
}

class Dog extends Animal{
    public void shout(){
        System.out.println("汪汪汪！");   // 重写shout()方法
    }
    public void seeDoor(){
        System.out.println("看门狗");
    }
}

class Cat extends Animal{
    public void shout(){
        System.out.println("喵喵喵~");  // 重写shout()方法
    }
}

public class TestPolym {
    public static void main(String[] args) {
        animalCry(new Dog());
        animalCry(new Cat());
        // 编译类型      // 运行时类型   
        Animal animal = new Dog();// 向上转型
        animal.shout();
        Dog d = (Dog)animal; // 向下强转
//      animal.seeDoor();  无法调用
        d.seeDoor(); // 成功调用
    }

    static void animalCry(Animal a){  // 等价于：Animal a = new Dog(),Animal a = new Cat()
        System.out.println("TestPolym.animalCry");
        a.shout();    // 可以出现多态
    }
}

对象的转型(casting)

父类引用指向子类对象，称为向上转型，属于自动类型转换
向上转型后的父类引用变量只能调用它编译类型的方法，不能调用它允许时类型的方法，这个时候需要进行类型的强制转换，称为向下转型

示例

package duotaiLearn;

public class TestPolym {
    public static void main(String[] args) {
        animalCry(new Dog());
        animalCry(new Cat());
        // 编译类型      // 运行时类型
        Animal animal = new Dog();
//      Animal animal1 = new Cat();
        animal.shout();
        Dog d = (Dog)animal; // 向上转型--d与animal是一个对象，只是转型了
//      animal.seeDoor();  无法调用
        d.seeDoor();
//      Cat c = (Cat)animal1;
//      c.CatchMouse();

//      直接写以下代码编译不会错，但允许会报错，可以new一个Cat()
//      Cat c = (Cat)animal1;
//      c.CatchMouse();

//      也可以：
//     if(animal instanceof Cat){
//      Cat c = (Cat)animal;
//      c.CatchMouse();
//    }

    }

    static void animalCry(Animal a){  // 等价于：Animal a = new Dog(),Animal a = new Cat()
        System.out.println("TestPolym.animalCry");
        a.shout();    // 可以出现多态
    }
}