Java中的三大特性：封裝、繼承、多型

封裝:

概念：封裝可以被認為是一個保護屏障，防止該類的代碼和資料被其他類隨意訪問，適當的封裝可以讓代碼更容易理解與維護，也加強了代碼的安全性，

原則：將屬性隱藏起來，若需要訪問某個屬性，提供公共方法對其訪問，主要運用就是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 }

賦值就通過構造方法就可以了

繼承：

概念：就是子類繼承父類的屬性和行為，使得子類物件具有與父類相同的屬性、相同的行為，子類可以直接  訪問父類中的非私有的屬性和行為，

好處：提高代碼的復用性，類與類之間產生了關系，是多型的前提，

代碼：

 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 }

面向物件編程的這三大特性，自己肯定總結的不夠全面，主要能給我一點印象，如果有錯的地方歡迎大家來糾錯

標籤：其他

上一篇：列舉很好用啊！為啥阿里不建議回傳值用列舉？？

下一篇：干掉 Jenkins！試試這些……