封裝:
概念：封裝可以被認為是一個保護屏障，防止該類的程式碼和資料被其他類隨意訪問，適當的封裝可以讓程式碼更容易理解與維護，也加強了程式碼的安全性。
原則：將屬性隱藏起來，若需要訪問某個屬性，提供公共方法對其訪問。主要運用就是JavaBean
程式碼：建立JavaBean
1 //建立一個Person類
2 public class Person {
3 private String name; //private私有方法修飾變數，把變數封裝起來
4 private int age;
5 //無參構造方法
6 public Person() {
7 }
8 //有參構造方法
9 public Person(String name, int age) {
10 this.name = name;
11 this.age = age;
12 }
13 //set、get方法
14 public String getName() {
15 return name;
16 }
17
18 public void setName(String name) {
19 this.name = name;
20 }
21
22 public int getAge() {
23 return age;
24 }
25
26 public void setAge(int age) {
27 this.age = age;
28 }
29 //重寫toString方法：便於輸出格式好看點
30 @Override
31 public String toString() {
32 return "Person{" +
33 "name='" + name + '\'' +
34 ", age=" + age +
35 '}';
36 }
37 }
賦值就通過構造方法就可以了
| 修飾符/類 | 本類 | 同一個包中的類 | 子類 | 其他類 |
| public | 可以 |
可以 | 可以 | 可以 |
| protect | 可以 | 可以 | 可以 | 不可以 |
| 無訪問修飾符 | 可以 | 可以 | 不可以 | 不可以 |
| private | 可以 | 不可以 | 不可以 | 不可以 |
繼承：
概念：就是子類繼承父類的屬性和行為，使得子類物件具有與父類相同的屬性、相同的行為。子類可以直接 訪問父類中的非私有的屬性和行為。
好處：提高程式碼的複用性。類與類之間產生了關係，是多型的前提。
程式碼：
1 //定義父類
2 public class Fu {
3 int age =1;
4 public void show(){
5 System.out.println("父類的方法");
6 }
7 public Fu() {
8 System.out.println("父類無參構造");
9 }
10 public Fu(String name){
11 System.out.println(name);//父類有參構造要在子類構造方法中通過super關鍵字賦值
12 }
13 }
14
15 //定義子類繼承父類
16 public class Zi extends Fu {
17 int age =2;//定義和父類相同的成員變數
18 public Zi() {
19 super("給父類有參構造賦值成功");//通過super關鍵字給父類有參構造賦值
20 }
21 public void show(){//成員方法重名：重寫
22 // super.show();//super關鍵字呼叫父類同名方法
23 System.out.println("子類的方法");
24 }
25 public void show1(){
26 System.out.println(this.age);//this關鍵字呼叫本類的成員方法
27 System.out.println(super.age);//super關鍵字呼叫父類的成員方法
28 }
29 }
30
31 //測試類
32 //父類構造方法有引數必須要子類的構造方法通過super關鍵字賦值，不然要報錯
33 public class ExtendsTest {
34 public static void main(String[] args) {
35 Zi zi = new Zi();
36 zi.show();
37 zi.show1();
38 }
39 }
輸出結果：
多型：
概念：多型是指同一行為，具有多個不同表現形式。
前提：
1. 繼承或者實現【二選一】
2. 方法的重寫【意義體現：不重寫，無意義】
3. 父類引用指向子類物件【格式體現】
當使用多型方式呼叫方法時，首先檢查父類中是否有該方法，如果沒有，則編譯錯誤；如果有，執行的是子類重寫後方法。
程式碼：
1 //父類
2 public abstract class Animal {
3 public abstract void eat();
4 }
5
6 //子類Dog繼承
7 public class Dog extends Animal {
8 @Override
9 public void eat() {//重寫父類的方法
10 System.out.println("狗吃東西");
11 }
12 }
13
14 //子類Cat繼承
15 public class Cat extends Animal {
16 @Override
17 public void eat() {//子類重寫
18 System.out.println("貓吃東西");
19 }
20 public void run(){//子類自己定義的方法
21 System.out.println("貓跑開了");
22 }
23 }
24
25
26 //測試類
27 public class Test {
28 public static void main(String[] args) {
29 Cat cat = new Cat();
30 Dog dog = new Dog();
31 // 多型規定，執行的是子類重寫的方法，無論之後再多的子類出現，我們都不需要編寫showXxxEat方法了，直接使用 showAnimalEat都可以完成。
32 showAnimaleat(cat);
33 showAnimaleat(dog);
34
35 /*// 向上轉型
36 Animal c =new Cat();
37 // 向下轉型
38 Cat cat = (Cat) c;
39 cat.run();*/
40 // instanceof關鍵字運用
41 Animal an =new Cat();
42 if (an instanceof Cat){
43 Cat cat1 = (Cat) an;
44 cat1.eat();
45 }else {
46 Dog dog1 = (Dog) an;
47 dog1.eat();
48 }
49 }
50 public static void showCateat(Cat cat){
51 cat.eat();
52 cat.run();
53 }
54 public static void showDogeat(Dog dog){
55 dog.eat();
56 }
57 public static void showAnimaleat(Animal animal){
58 animal.eat();
59 }
60 }
面向物件程式設計的這三大特性，自己肯定總結的不夠全面，主要能給我一點印象，如果有錯的地方歡迎大家來糾錯