继承

一． 面向对象的三大特征：封装性、多态性、继承性。

1. 继承性
   作用：简化代码（减少代码冗余）
   重写：方法名相同，参数名也得相同（当父类方法不能满足子类的需求，子类中重写方法访问修饰符不能比子类更严格）
   Equals和hashcode：重写时两个方法要一起出现。

2. 访问修饰符
   无限制 继承 本类 同包
   Public(公有的) T T T T
   Protected(受保护的) T T T
   Private(私有的) 本类
   默认 T T

3. Static（静态的、唯一的）
   只能修饰属性和方法、静态方法中不能出现非静态元素

4. Final（不可变的）
   类、属性、方法和局部变量都能被修饰。
   被final修饰过的类就不能有子类。
   被final修饰过的方法不能被重写。
   被final修饰过的属性必须给赋值，若不赋初值需要在构造函数时赋初值。
   局部变量：可以不赋初值，一旦赋值，值将不能被改变。
   例1. 定义一个名为Vehicles（交通工具）的基类，该类中应包含String类型的成员属性brand（商标）和color（颜色），还应包含成员方法run（行驶，在控制台显示“我已经开动了”）和showInfo（显示信息，在控制台显示商标和颜色），并编写构造方法初始化其成员属性。
   编写Car（小汽车）类继承于Vehicles类，增加int型成员属性seats（座位），还应增加成员方法showCar（在控制台显示小汽车的信息），并编写构造方法。 编写Truck（卡车）类继承于Vehicles类，增加float型成员属性load（载重），还应增加成员方法showTruck（在控制台显示卡车的信息），并编写构造方法。 在main方法中测试以上各类。

   public class Vehicles {
   public String brand;
   public String color;
   public void run(){
   System.out.println(“我已经开动了”);
   }
   public void showInfo(){
   System.out.println(brand+" “+color);
   }
   public Vehicles(){
   this.brand = brand;
   this.color = color;
   }
   public Vehicles(String brand, String color) {
   this.brand = brand;
   this.color = color;
   }
   }
   public class Car extends Vehicles {
   public int seats;
   public void showCar(){
   System.out.println(brand+” “+color+” “+seats);
   }
   public Car(String brand, String color,int seats) {
   super(brand,color);
   this.seats = seats;
   }
   }
   public class Truck extends Vehicles {
   public float load;
   public void showTruck(){
   System.out.println(brand+” “+color+” "+load);
   }
   public Truck(String brand, String color,float load) {
   super(brand,color);
   this.load = load;
   }
   }
   public class Test {
   public static void main(String[] args) {
   Car c = new Car(“丰田”,“白色”,5);
   c.showCar();
   Truck t = new Truck(“东风”,“黄色”,55);
   t.showTruck();
   }
   }

例2．编写一个类Calculate1，实现加、减两种运算，然后，编写另一个派生类Calculate2，实现乘、除两种运算。

public class Calculate1 {
    public int add;
    public int minue;
    public int add(int a,int b){
    return a+b;
  }
    public int minue(int a,int b){
    	return a-b;
    }
	public Calculate1(int add, int minue) {
		super();
		this.add = add;
		this.minue = minue;
	}
	public Calculate1() {
		this.add = add;
		this.minue = minue;
}
}

public class Calculate2 extends Calculate1 {
public int mul;
public int div;
public int mul(int a,int b){
	return a*b;
}
public  int div(int a,int b){
	return a/b;
}
public Calculate2(int add, int minue, int div, int mul) {
	super(div, mul);
	this.div = div;
	this.mul = mul;
}
public Calculate2() {
	super();
	this.div = div;
	this.mul = mul;
}
}

public class Test1 {

	public static void main(String[] args) {
		Calculate1 c1 =new Calculate1();
		System.out.println(c1.add(5, 6));
		System.out.println(c1.minue(3, 26));
		Calculate2 c2 =new Calculate2();
		System.out.println(c2.div(8, 9));
		System.out.println(c2.mul(6,2));
	}

}

例3. 编写一个控制台应用程序，完成下列功能，并回答提出的问题。
1) 创建一个类A，在构造函数中输出“A”，再创建一个类B，在构造函数中输出“B”。
2) 从A继承一个名为C的新类，并在C内创建一个成员变量B。不要为C创建构造函数。
3) 在Main方法中创建类C的一个对象，写出运行程序后输出的结果。
4) 如果在中也创建一个构造函数输出“C”，整个程序运行的结果又是什么？

public class A {
    public A(){
	System.out.println('A');
}
}
public class B {
	 public B(){
     System.out.println('B');
}
}
public class C extends A {
    public char B;
}
public class Test2 {
	public static void main(String[] args) {
	C c = new C();
	}
}

例4. 建立三个类：居民、成人、官员。居民包含身份证号、姓名、出生日期，而成人继承自居民，多包含学历、职业两项数据；官员则继承自成人，多包含党派、职务两项数据。要求每个类的字段都以属性的方式对外提供数据输入输出的功能。

public class People {
    public String name;
    public String id;
    public String birth;
	public People(String id, String birth, String name) {
		super();
		this.id = id;
		this.birth = birth;
		this.name = name;
		System.out.println("姓名"+name);
		System.out.println("身份证号码"+id);
		System.out.println("生日"+birth);
	}
	public People() {
		super();
		this.id = id;
		this.birth = birth;
		this.name = name;
	}
}
public class Adult extends People {
    public String xueli;
    public String zhiye;
	public Adult(String id, String birth, String name, String xueli, String zhiye) {
		super(id, birth, name);
		this.xueli = xueli;
		this.zhiye = zhiye;
		System.out.println("学历"+xueli);
		System.out.println("职业"+zhiye);
	}  
	public Adult(){
		super();
		this.xueli = xueli;
		this.zhiye = zhiye;
	}  
}
public class Officer extends Adult {
	public String dangpai;
	public String zhiwu;
	public Officer(String id, String birth, String name, String xueli, String zhiye,
			String dangpai, String zhiwu) {
		super(id, birth, name, xueli, zhiye);
		this.dangpai = dangpai;
		this.zhiwu = zhiwu;
		System.out.println("党派"+dangpai);
		System.out.println("职务"+zhiwu);
	}
	public Officer() {
		super();
		this.dangpai = dangpai;
		this.zhiwu = zhiwu;
}
}
public class Test3 {
	public static void main(String[] args) {
		Officer o = new Officer("1997-03-26","630105199","yhl","本科","学生","共产党","程序员");		

	}

}