封裝

private int age（私有 類名稱 屬性名稱）。特別注意的是數組也屬于java類。private 可以封裝類、屬性、方法。

繼承

1、子類可以直接繼承父類的操作，并且子類還可以繼續擴充自己的功能。

package practice;
class A{
    private String name;
    private int age;
    
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name ;
    }
    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return this.age;
    }
}
class B extends A{
    private String school;
    public void setSchool(String school){
        this.school = school;
    }
    public String getSchool(){
        return this.school;
    }
}
public class exte {
    public static void main(String [] args){
        A a = new A();
        B b = new B();
        a.setName("張三");
        a.setAge(23);
        b.setSchool("大學也");
        System.out.println("姓名："+a.getName()+",年齡："+a.getAge()+"，學校："+b.getSchool());
    }
}

2、Java不允許多重繼承，允許多層繼承。

//此為錯誤繼承
class A{
}
class B{
}
class C extends A,B{
}
//這是對的
class A{
}
class B extends A{
}
class C extends B{
}

3、子類構造調用一定會先執行父類操作，顯式/隱式操作

package practice;
class A1{
    private String name;
    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }
}
class B1 extends A1{
      /*public void fun(){
  System.out.println(name);    //這里用super.name調用也不對，私有屬性只能在本類使用，父類不可使用
}   */      //此方法操作錯誤，B1的name隱式繼承樂A1的name，不能直接對私有屬性進行操作，而可以隱式繼承
}
//可以這樣理解把A1當作父親，B1當作孩子，
public class exten {
    public static void main(String [] args){
        B1 b = new B1();
        b.setName("張三");
        System.out.println(b.getName());
    }
}

super() 操作/this()操作；沒有無參構造時使用super()

package practice;
class D{
    public D(){
        System.out.println("A");
    }
}
class E extends D{
    public E(){
        super();   //若父類有無參構造，加不加都可以，子類對象實例化時會默認調用父類的無參構造
        System.out.println("B");
    }
}
public class ex1 {
    public static void main(String [] args){
        new E();
    }
}
-----------------------------------------------------------------------------------
package practice;
class D{
    public D(String title){
        System.out.println("A");
    }
}
class E extends D{
    public E(String title){
        super(title);  // this（）當前類中查找，extends（）父類查找，向父類查找
        System.out.println("B");
    }
}
public class ex1 {
    public static void main(String [] args){
        new E("d");
    }
}

多態

兩種形式描述：
方法的多態性：方法的重載，同一個方法名稱，會根據傳入參數的類型及個數的不同執行不同的方法體；方法的覆寫：同一個方法會根據子類的不同，實現不同的功能。
對象的多態性：指的是發生在繼承關系類中，子類和父類的轉換。
向上轉型：父類 父類對象 = 子類實例； //自動完成
向下轉型：子類 子類對象 = （子類）父類實例。 //強制完成
向上轉型：

class A{
    public void print(){
        System.out.println("A");
    }
}
class B extends A {
    public void print(){
        System.out.println("B");
    }
}
------------------------------------------------------
//向上
public class Duo{
    public static void main(String [] args){
        A a = new B();
        a.print();
    }
}
-------------------------------------------------------
//向下
public class Duo{
    public static void main(String [] args){
        A a = new B();
        B b = (B)a;
        b.print();
    }
}

向上轉型可以實現參數的統一

class A{
    public void print(){
        System.out.println("A");
    }
}
class B extends A {
    public void print(){
        System.out.println("B");
    }
}
class C extends A{
    public void print(){
        System.out.println("C");
    }
}
public class Duo{
    public static void main(String [] args){
      //子類均可以用父類接受
        A a1 = new B();
        A a2 = new C();
        a1.print();
        a2.print();
    }
}

向下轉型：指的是父類要調用子類自己的特殊的方法。

class A{
    public void print(){
        System.out.println("A");
    }
}
class B extends A {
    public void print(){
        System.out.println("B");
    }
    public void fun(){
        System.out.println("fun");
    }
}
public class Duo{
    public static void main(String [] args){
        A a1 = new B();
        B b = (B)a1;
        b.fun();
    }
}

擴充方法

class A{
    public void print(){
        System.out.println("A");
    }
}
class B extends A {
    public void print(){
        System.out.println("B");
    }
    public void fun(){
        System.out.println("fun");
    }
}
public class Duo{
    public static void main(String [] args){
        funa(new B());
    }
    public static void funa(A a){
        B b = (B)a;
        b.fun();
    }
}

兩個沒有關系的類的對象強制向下轉型時所帶來的異常
Exception in thread "main" java.lang.ClassCastException: A cannot be cast to B
at Duo.main(Duo.java:14)

class A{
    public void print(){
        System.out.println("A");
    }
}
class B extends A {
    public void print(){
        System.out.println("B");
    }
}
public class Duo{
    public static void main(String [] args){
        A a = new A();   //A a = new B();
        B b = (B)a;
        b.print();
    }
}