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 }

子类

---