This/導包/繼承/重寫

Lesson Nine　　　　　　　　　　　　　　　　　　　　　　　　　　2018-04-27　　02:05:08

 this:

 1.可以用來修飾屬性、方法、構造器
 2.this理解為當前對象或當前正在創建的對象.比如：this.name,this.show();

 1 class TriAngle{
 2     private double base;
 3     private double height;
 4     
 5     public TriAngle(){
 6         base =1.0;
 7         height = 1.0;
 8     }
 9     public TriAngle(double height, double base){
10         this.base = base;
11         this.height=height;
12     }
13     
14     public double getBase(){
15         return base;
16     }
17     public double getHeight(){
18         return height;
19     }
20     public void setBase(double base){
21         this.base = base;
22     }
23     public void setHeight(double height){
24         this.height = height;
25     }
26     public double findArea(){
27         return this.height*this.base/2;
28         
29     }
30 }

 3.可以在構造器中通過“this(形參)”的方式顯示的調用本類中其它重載的指定的構造器。

 1 class Person {
 2     private String name;
 3     private int age;
 4 
 5     public Person() {
 6         name = "Lucy";
 7     }
 8 
 9     public Person(String name) {
10         System.out.println("");
11         this.name = name;
12     }
13     
14     
15     public Person(String name, int age) {
16         this(name);  
17         System.out.println("");
18         this.age = age;
19     }

總結：

１、表示對當前對象的引用！

２、表示用類的成員變數，而非函數參數，註意在函數參數和成員變數同名是進行區分！其實這是第一種用法的特例，比較常用，所以那出來強調一下。

３、用於在構造方法中引用滿足指定參數類型的構造器（其實也就是構造方法）。但是這裡必須非常註意：只能引用一個構造方法且必須位於開始！

 4、若一個類中有n個構造器，那麼最多有n-1個構造器中使用了this(形參);

 import:

* 1)顯式導入指定包下的類或介面
* 2)寫在包的聲明和源文件之間
* 3)如果需要引入多個類或介面，那麼就併列寫出
* 4)如果導入的類是java.lang包下的，如：System String Math等，就不需要顯式的聲明。
* 5)import static 表示導入指定類的static的屬性或方法
* 6)導入java.lang.*只能導入lang包下的所有類或介面，不能導入lang的子包下的類或介面

 1 import java.util.ArrayList;
 2 import java.sql.Date;
 3 import java.util.Date;
 4 import java.util.List;
 5 import java.util.Scanner;
 6 import java.util.*;
 7 
 8 
 9 public static void main(String[] args) {
10 
11         java.util.Date d = new java.util.Date();
12         java.sql.Date d1 = new java.sql.Date(1);
13         
14         Scanner scanner = new Scanner(System.in);
15         List list = new ArrayList();
16 ｝

繼承：
1.為什麼要設計繼承？！
　　　　extends:子類是對父類功能的“擴展”，明確子類不是父類的子集。
2.通過“class A extends B”類實現類的繼承 A:子類，B:父類(基類/SuperClass)　

1 public class Student extends Person{            }

3.子類繼承父類以後，父類中聲明的屬性，方法， 子類就可以獲取到。

4.當父類中有私有的屬性或方法時，子類同樣可以獲取得到，
只是由於封裝性的設計，使得子類不可以直接調用。

5.子類除了通過繼承，獲取父類的結構之外，還可以定義自己的特有成份 如：方法、屬性。

6.java中類的繼承性只支持單繼承，即：一個子類只能繼承一個父類。反之，一個父類可以有多個子類
7.子類父類都是相對的概念。

 1 package Person;
 2 
 3 public class Person {
 4     private String name;
 5     private int age;
 6 
 7     public String getName() {
 8         return name;
 9     }
10 
11     public void setName(String name) {
12         this.name = name;
13     }
14 
15     public int getAge() {
16         return age;
17     }
18 
19     public void setAge(int age) {
20         this.age = age;
21     }
22 
23     public void eat() {
24         System.out.println("Eating!");
25     }
26 
27     public void walk() {
28         System.out.println("walking");
29     }
30 
31 }

方法的重寫(override overwrite)：對父類同名方法的重寫、覆蓋   

格式：修飾符 返回值類型 方法名 (參數列表) {} 
1.前提：有子類繼承父類
2.子類繼承父類以後，若父類的方法對子類不適用，
那麼子類可以對父類的方法重寫(覆蓋)
3.重寫的規則：
3.1要求子類方法的“返回值類型 方法名 (參數列表)”與父類的一樣
3.2子類方法的修飾符許可權不能小於父類
3.3*若父類方法拋異常，那麼子類方法拋的異常類型不能大於父類的。
3.4*子父類的方法必須同為static或同為非staticc的。

 1 package Person;
 2 
 3 public class Student extends Person{
 4 
 5     private String school;
 6 
 7     public Student() {
 8 
 9     }
10 
11     public Student(String name, int age) {
12     
13         getAge();
14         this.setName(name);
15         this.setAge(age);
16     }
17 
18     
19     public void eat(){
20         System.out.println("I'm Eating!");
21     }
22     public void walk(){
23         System.out.println("I'm walking");
24     }
25     public void show() {
26         System.out.println("I'm a Student!");
27         
28     }
29 
30 }