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 }