目录

继承

作用

实现

示例

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);  // trueSystem.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{@Overridepublic 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));   // falseTestObject t5 = new TestObject(2,"李四","123456");System.out.println(t4.equals(t5));   // 重写前：false（对象不一样） 重写后：只比较id，返回 ：true(id值一样)
​
​}
​// 重写equals()方法@Overridepublic 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);  // 33System.out.println(value);  // 33System.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();    // 可以出现多态}
}