1 继承（二）

　　案例：Demo1

public class Demo1 {
  public static void main(String[] args) {
	Bmw bmw = new Bmw();
	bmw.name = "宝马";
	bmw.no = "555555";
	bmw.type = "豪华版";
	bmw.price = 200000.1;
	bmw.color = "白色";
	bmw.show();
	bmw.start();
	bmw.run();
	bmw.stop();
  }
}
class Car{//父类
//属性
  String name;
  String no;
  int speed = 0;
  String color;
//方法
  void start(){
	speed = 100;
	System.out.println(name+"启动了");
  }
  void run(){
	System.out.println(name+"在行驶，当前"+
			"的速度是"+speed);  
  }
  void stop(){
	speed = 0;
	System.out.println(name+"刹车了，当前"+
			"的速度是"+speed);
  }
}
//编写一个Car类（父类）
//属性：车名，车牌，速度(int speed=0)，颜色
//方法：void start():启动,speed=100,输出启动了
//void run():行驶，输出车名以及当前的速度
//void stop():刹车,speed=0,输出车名以及当前速度
class Bmw extends Car{
//属性
  double price;
  String type;
//方法	
  void show(){
	System.out.println(name+","+no+","
			+speed+","+color+","+price
			+","+type);  
  }
}

2 变量的隐藏(属性的覆盖)

　　子类编写的属性的名字跟父类中继承过来的属性名一致，子类编写的属性会覆盖从父类中继承过来的属性。
　　案例：Demo2

public class Demo2 {
  public static void main(String[] args) {
	Foo2 foo = new Foo2();
	System.out.println(foo.name);
  }
}
class Foo1{
  String name = "卫青";	
}
class Foo2 extends Foo1{
  String name = "霍去病";  	
}

public class Demo3 {
  public static void main(String[] args) {
	Eoo2 eoo = new Eoo2();
	System.out.println(eoo.num1);//true
  }
}
class Eoo1{
  int num1 = 100;	
}
class Eoo2 extends Eoo1{
  boolean num1 = true;	
//变量的隐藏只看子类和父类中的属性的名字是否一致，
//跟类型无关。  
}

　　变量的隐藏跟属性的类型无关，只要子类编写的属性的名字跟父类中继承过来的属性名一致，就覆盖了。

3 方法重写(方法覆盖)

　　子类编写的方法覆盖了从父类中继承过来的方法。
　　1) 方法重写要求子类编写的方法的名字和参数，必须跟要覆盖父类中的方法的名字和参数一致。
　　2) 参数一致：参数的类型和个数一致，跟参数的名字无关。
　　　　案例：Demo4

public class Demo4 {
  public static void main(String[] args) {
	Koo2 koo = new Koo2();
	koo.f1();
  }
}
class Koo1{
  void f1(){
	System.out.println("今天天气很好");
	System.out.println("父类Koo1中编写的方法");
  }	
}
class Koo2 extends Koo1{
  void f1(){
	System.out.println("子类Koo2中重写" +
			"父类Koo1中的方法f1()");  
  }	
}

public class Demo5 {
  public static void main(String[] args) {
	User1 user = new User1();
	user.name = "张三";
	user.age = 26;
	user.job = "经理";
	user.address = "北京";
	user.email = "san@126.com";
	user.salary = 30000.1;
	user.show();
  }
}
class Person1{//父类
//属性
  String name;
  int age;
  String job;
  double salary;
//方法	
  void show(){
	System.out.println(name+","+age+","
			+job+","+salary);  
  }
}
//设计一个Person1（父类）
//属性：姓名，年龄，职位，工资
//方法：void show():输出每一个属性的值
class User1 extends Person1{
//属性
  String address;
  String email;
//方法	
  void show(){
	System.out.println(name+","+age+","
			+job+","+salary+","+address
			+","+email);  
  }
}

public class Demo6 {
  public static void main(String[] args) {
	Zoo2 zoo = new Zoo2();
	zoo.f1(100,200);
  }
} 
class Zoo1{
  void f1(int a,int b){
	int sum = a + b;
	System.out.println("sum="+sum);
	System.out.println("父类Koo1中的方法" +
			"f1()");
  }	
}
class Zoo2 extends Zoo1{
  void f1(int num1,int num2){
	int result = num1 * num2;
	System.out.println("result="+result);
	System.out.println("子类Zoo2中的方法" +
			"f1()重写父类Zoo1中的方法f1()");
  }	
}

　　3) 方法重写跟方法重载的区别？
　　　　a) 方法重写在子类和父类之间，子类编写的方法覆盖了从父类中继承过来的方法。方法重载在一个类的内部，方法名相同，参数不同的多个方法。
　　　　b) 方法重写要求子类和父类中要重写方法的名字和参数一致。参数一致，参数的类型和个数一致，跟参数的名字无关。方法重载中要求重载的多个方法的名字一致，参数要不同，参数不同，参数的类型或者个数不同，跟参数的名字无关。
　　　　c) 方法重写的目的，使用子类重新编写的方法来覆盖从父类中继承过来的方法。方法重载是把功能相似的方法起同一个名字，用户只需要记住一个名字，就可以调用多个方法，减少用户的记忆量，方便方法的使用。


4 继承中的构造方法

　　子类可以继承父类的属性和方法，但是不能继承父类中的构造方法，可以在子类的构造方法中，调用父类中的构造方法。
　　1）如果父类中没有空参（没有参数）构造方法，则子类必须在自己的构造方法的第1行，使用super(参数)来调用父类中的带参数的构造方法。
　　　　super(参数)：在子类构造方法的第1行使用，调用父类中带参数的构造方法。
　　　　案例：Demo7

public class Demo7 {
  
}
class Noo1{
//属性
  String name;
  int age;
  double salary;
//构造方法	
  Noo1(String name,int age,double salary){
	this.name = name;
	this.age = age;
	this.salary = salary;
  }  
}
class Noo2 extends Noo1{
//属性	
  String address;
  String phone;
//构造方法
  Noo2(String name,int age,double salary,
		  String address,String phone){
//super(参数)：在子类构造方法第1行使用，调用父类
//中带参数的构造方法
	super(name,age,salary);
	this.address = address;
	this.phone = phone;
  }
}

public class Demo8 {
  public static void main(String[] args) {
	User2 user = 
		new User2("徐达",36,"将军",
		  "漠北",2000000.1,"da@126.com");
    user.showAll();
  }
}
class Person2{
//属性
  String name;
  int age;
  String job;
  String address;
//构造方法
  Person2(String name,int age,String job,
		  String address){
	this.name = name;
	this.age = age;
	this.job = job;
	this.address = address;
  }	
//方法	
  void show(){
	System.out.println(name+","+age+","
			+job+","+address);  
  }
}
class User2 extends Person2{
//属性
  double salary;
  String email;
//构造方法
  User2(String name,int age,String job,
		  String address,double salary,
		  String email){
	super(name,age,job,address);
	this.salary = salary;
	this.email = email;
  }	
//方法
  void showAll(){
	this.show();
	System.out.println("工资："+salary);
	System.out.println("邮箱："+email);
  }
}

　　2）如果父类中含有空参的构造方法，则子类根据需要任何编写自己的构造方法，而不需要强制使用super(参数)来调用父类中的构造方法。
　　　　案例：Demo9

public class Demo9 {

}
class Moo1{
//属性
  String name;
  int age;
  String job;
  String address;
//构造方法	
  Moo1(String name,int age,String job,
		  String address){
	this.name = name;
	this.age = age;
	this.job = job;
	this.address = address;
  }
  Moo1(){
	  
  }
}
class Moo2 extends Moo1{
//属性
  String phone;
  double comm;
//构造方法	
  Moo2(String name,int age,String job,
		  String address,String phone,
		  double comm){
/*	  
	this.name = name;
	this.age = age;
	this.job = job;
	this.address = address;
*/
	super(name,age,job,address);
	this.phone = phone;
	this.comm = comm;
  }
}

public class Demo10 {
  public static void main(String[] args) {
	Midea midea = 
		new Midea("美的","壁挂式",
			  27,"黑色",5000.22);
	midea.show();
	midea.hot(3);
	midea.cool(8);
  }
}
class Kongtiao{
//属性
  String name;
  String type;
  int degree;
  String color;
//构造方法
  Kongtiao(String name,String type,
		  int degree,String color){
	this.name = name;
	this.type = type;
	this.degree = degree;
	this.color = color;
  }	
  Kongtiao(){
	  
  }
//方法
  void show(){
	System.out.println(name+","+type+","
			+degree+","+color);  
  }
  void hot(int degree){
	this.degree = this.degree + degree;
	System.out.println(name+"升高了"+degree
		+"度以后，当前的温度是"+this.degree);
  }
  void cool(int degree){
	this.degree = this.degree - degree;
	System.out.println(name+"降低了"+degree
		+"度以后，当前的温度是"+this.degree);
  }
}
//设计一个Kongtiao类（父类）
//属性：名称，类型，温度（int degree），颜色
//构造方法：1）给每一个属性赋值  2）空参的构造方法
//方法：void show():输出名称，类型，温度，颜色
//void hot(int degree):升高degree度
//this.degree = this.degree+degree
//void cool(int degree):降低degree度
class Midea extends Kongtiao{
//属性
  double price;
//构造方法
  Midea(String name,String type,
		  int degree,String color,
		  double price){
	super(name,type,degree,color);
	this.price = price;
  }	
//方法	
  void show(){
	System.out.println(name+","+type+","
			+degree+","+color+","+price);  
  }
}

　　3）在企业中，一般都建议在父类中编写一个空参的构造方法，方便子类构造方法的编写。
　　　　案例：Demo11

public class Demo11 {
  public static void main(String[] args) {
	Worker worker = 
		new Worker("韦一笑",32,"侠客",
		  2000.1,"光明顶","xiao@126.com");
    worker.show();
    worker.showAll();
    worker.showYearSal();
    Manager manager = 
    	new Manager("任我行",45,"教主",
    	 2001.1,10000000.1,"1333333333");
    manager.show();
    manager.showYearSal();
  }
}
class Emp{
//属性：姓名，年龄，职位，工资
  String name;
  int age;
  String job;
  double salary;
//构造方法
  Emp(String name,int age,String job,
		  double salary){
	this.name = name;
	this.age = age;
	this.job = job;
	this.salary = salary;
  }	
  Emp(){
	  
  }
//方法
  void show(){
	System.out.println(name+","+age+","
			+job+","+salary);  
  }
  void showYearSal(){
	double result = salary * 12;
	System.out.println(name+"的年薪是"+
			result);
  }
}
class Worker extends Emp{
//属性：姓名，年龄，职位，工资，地址，邮箱
  String address;
  String email;	
//构造方法
  Worker(String name,int age,String job,
		  double salary,String address,
		  String email){
	super(name,age,job,salary);
	this.address = address;
	this.email = email;
  }	
//方法	
  void showAll(){
	this.show();
	System.out.println("地址："+address);
	System.out.println("邮箱："+email);
  }
}
class Manager extends Emp{
//属性：姓名，年龄，职位，工资，奖金，电话
  double comm;
  String phone;
//构造方法：
  Manager(String name,int age,String job,
		  double salary,double comm,
		  String phone){
	super(name,age,job,salary);  
	this.comm = comm;
	this.phone = phone;
  }//方法：
  void show(){
	System.out.println(name+","+age+","
			+job+","+salary+","+comm+
			","+phone);  
  }
  void showYearSal(){
	double result = salary*12+comm;
	System.out.println(name+"年薪是"+result);
  }
}

　　　　综合案例：
　　　　　　设计一个Emp类（父类）
　　　　　　属性：姓名，年龄，职位，工资
　　　　　　构造方法：1）给每一个属性赋值 2）空参的构造方法
　　　　　　方法：void show():输出姓名，年龄，职位，工资
　　　　　　　　void showYearSal(): 输出姓名和年薪(工资*12)
　　　　　　编写一个Worker类（子类），继承Emp
　　　　　　属性：姓名，年龄，职位，工资，地址，邮箱
　　　　　　构造方法：给所有属性赋值
　　　　　　方法：void showAll():输出每一个属性值
　　　　　　　　void showYearSal()：输出姓名和年薪(工资*12)
　　　　　　编写一个Manager类（子类），继承Emp
　　　　　　属性：姓名，年龄，职位，工资，奖金，电话
　　　　　　构造方法：给每一个属性赋值
　　　　　　方法：void show():输出每一个属性值
　　　　　　　　void showYearSal():输出姓名和年薪(工资*12+奖金)
　　　　　　在main中，分别创建Worker和Manager对象，调用其方法


5 访问控制修饰符(一)
　　1）public：公共的，可以用来修饰类，属性，构造方法，以及方法，被public修饰类，属性，构造方法以及方法，可以任意进行访问。
　　　　案例：Demo12

public class Demo12 {
  public static void main(String[] args) {
	Coo coo1 = new Coo();
	System.out.println(coo1.name);
  }
}
class Coo{
  public String name = "张辽";	
}

　　2）private：私有，可以用来修饰属性，构造方法以及方法，被privae修饰属性，构造方法以及方法，只能在本类的内部访问，外界无法访问。
　　　　案例：Demo13

public class Demo13 {
  public static void main(String[] args) {
	Yoo yoo = new Yoo();
	System.out.println(yoo.name);
//	System.out.println(yoo.age);
//被private修饰的属性，只能在本类的内部访问，外界
//无法访问
	yoo.showAge();
  }
}
class Yoo{
  public String name = "张三";
  private int age = 21;
  public void showAge(){
	System.out.println("age="+age); 
  }
}