最長不下降子序列
-
該露的露，該藏的藏：我們程式設計要追求“高內聚，低耦合”，高內聚就是類的內部資料操作細節自己完成，不允許外部干涉；低耦合：僅暴露少量的方法給外部使用
-
封裝（資料的隱藏） ： 通常，禁止直接訪問一個物件中資料的實際表示，而應通過操作介面來訪問，這稱為資訊隱藏
-
記住這句話：屬性私有，get/set
-
封裝的意義：
-
提高程式的安全性，保護資料
-
隱藏程式碼的實現細節
-
統一介面
-
增加系統的可維護性
-
//學生類 private:私有
public class Student {
//屬性：欄位 屬性私有
private String name;
private int id;
private char sex;
//提供一些可以操作這些屬性的方法
//提供一些public的get、set方法 alt+insert 一鍵生成
public String getName(){
return this.name;
}
public void setName(String name){
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public char getSex() {
return sex;
}
public void setSex(char sex) {
if(sex == '男' || sex == '女'){
this.sex = sex;
}else {
this.sex = '？';
}
}
//方法
public void study(){
System.out.println(this.name+"在學習");
}
}
/*
public class Application {
public static void main(String[] args) {
Student s1 = new Student();
s1.setName("小明");
System.out.println(s1.getName());
s1.setSex('豬');//不合法的
System.out.println(s1.getSex());
}
}
*/
繼承
-
繼承的本質是對某一批類額抽象，從而實現對現實世界更好的建模
-
extends的意思是“擴充套件”。子類是父類的擴充套件
-
Java中類只有單繼承，沒有多繼承：子類只能有一個父類
-
繼承是類與類之間的一種關係。除此之外，類與類之間的關係還有依賴、組合、聚合等
-
繼承關係的兩個類，一個為子類（派生類），一個為父類（基類）。子類繼承父類，使用關鍵字extends來表示
-
子類與父類之間，從意義上講應該具有“is a”的關係
-
object類：在Java中，所有的類，都預設直接或者間接繼承Object類
-
super - this
-
用super呼叫父類的構造方法，必須在構造方法的第一個
-
super必須只能出現在子類的方法或者構造方法中
-
super和this不能同時呼叫構造方法
-
super代表父類物件的引用 this代表本身呼叫者這個物件
-
super只能在繼承條件才可以使用 this沒有繼承也可以使用
-
super()父類的構造 this()本類的構造
-
//在Java中，所有的類，都預設直接或者間接繼承Object類
//父類
public class Person {
protected String name = "xiaoming";
//私有的東西無法被子類直接使用，需要相應父類介面
private int money = 10_0000_0000;
public Person(){
System.out.println("Person無參構造執行了");
}
public int getMoney() {
return money;
}
public void setMoney(int money) {
this.money = money;
}
public void say(){
System.out.println("說了一句話");
}
public void print(){
System.out.println("Person");
}
}
//學生 is 人
public class Student extends Person{
//Ctrl + H 檢視當前類的子類與父類
private String name ="xiaohong";
public Student(){
//隱藏程式碼：呼叫父類的無參構造器
super();//呼叫父類的構造器，必須要在子類構造器的第一行
System.out.println("Student無參構造執行了");
}
public void test(String name){
System.out.println(name);
System.out.println(this.name);
System.out.println(super.name);
}
public void test2(){
print();
this.print();
super.print();
}
public void print(){
System.out.println("Student");
}
}
-
方法重寫--->多型
-
需要有繼承關係，子類重寫父類的方法
-
方法名必須相同
-
引數列表必須相同
-
修飾符：範圍可以擴大但不能縮小 public > protected > default > private
-
丟擲的異常:範圍可以被縮小，但不能擴大
-
為什麼需要重寫：父類的功能，子類不一定需要，或者不一定滿足
-
快捷鍵 alt+insert
-
public class A {
public static void test(){
System.out.println("A=>test()");
}
public void test2(){
System.out.println("A=>test()2");
}
}
//重寫都是非靜態方法的重寫 和屬性無關
public class B extends A{
public static void test(){
System.out.println("B=>test()");
}
public void test2(){
System.out.println("B=>test()2");
}
}
/*
import oop.類與物件.Demo02.A;
import oop.類與物件.Demo02.B;
//一個專案應該只存在一個main方法
public class Application {
public static void main(String[] args) {
//靜態的方法的呼叫只和左邊，定義的資料型別有關
B b= new B();
b.test();//B=>test()
//父類的引用指向了子類
A a =new B();
a.test();//B=>test()
//靜態方法是類的方法，非靜態方法是物件的方法
b.test2();//B=>test()2
a.test2();//B=>test()2
}
}
*/
多型
-
即同一方法可以根據傳送物件的不同而採用多種不同的行為方式
-
一個物件的實際型別是確定的，但可以指向物件的引用型別有很多（父類，有關係的類）
-
多型存在的條件
-
有繼承關係
-
子類重寫父類方法
-
父類引用子類物件 Person s2 = new Student();
-
-
注意：多型是方法的多型，屬性沒有多型.
-
兩者沒有關係 會出現型別轉換異常！ ClassCastException!
-
static方法 屬於類，它不屬於例項 final修飾：常量 private方法 這三者無法重寫
-
public class Person {
public void run(){
System.out.println("run");
}
}
public class Student extends Person{
-
Instanceof 判斷一個物件是什麼型別
public class Application {
public static void main(String[] args) {
//Object > String
//Object > Person > Teacher
//Object > person > Student
Object a = new Student();
//X instanceof Y; //能不能編譯通過，取決於XY是否存在父子關係
System.out.println(a instanceof Student);//true
System.out.println(a instanceof Person);//true
System.out.println(a instanceof Object);//true
System.out.println(a instanceof Teacher);//false
System.out.println(a instanceof String);//false
System.out.println("===================");
Person b = new Student();
System.out.println(b instanceof Student);//true
System.out.println(b instanceof Person);//true
System.out.println(b instanceof Object);//true
System.out.println(b instanceof Teacher);//false
//System.out.println(b instanceof String);//編譯報錯
Student c = new Student();
System.out.println(c instanceof Student);//true
System.out.println(c instanceof Person);//true
System.out.println(c instanceof Object);//true
//System.out.println(c instanceof Teacher);//編譯報錯
//System.out.println(c instanceof String);//編譯報錯
}
}
型別轉換--->引用型別之間的型別轉換
public class Application {
public static void main(String[] args) {
Person a = new Student();
//型別之間的轉化：父轉子 需要強制型別轉換
Student b = (Student) a;
//子類轉父類 可能丟失自己本來的一些方法
Person c =b;
}
}
/*
1.父類引用指向子類的物件
2.把子類轉換為父類，向上轉型；
3.把父類轉換為子類，向下轉型；強制轉換
4.方便方法的呼叫，減少重複的程式碼
*/