Java学习心得（第三周）---面向对象的三大特征

Java面向对象的三大特征为：封装、继承和多态，下面说说我对三大特性的理解。

1.封装

在对象的外部，为对象的属性赋值，可能存在非法数据的录入。
Java中的封装是指类尽可能隐藏对象的内部实现细节，控制对象的修改及访问权限，增加安全性。
封装又分为属性的封装和方法的封装。把属性定义为私有的，它们通过set和get方法来对属性进行赋值、取值。

public class Animal {
	public static void main(String[] args) {
		Dog d=new Dog("小花",2);	
		System.out.println(d.getName()+"今年"+d.getAge()+"岁了");
	}
}
class Dog{
	private String  name;
	private int age;
	public Dog(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

在Dog类中，有两个属性 ：姓名、年龄，访问属性为private,通过set / get 方法进行赋值和取值

2.继承

程序中的继承，是类与类之间特征和行为的一种赠与或获得。两个类之间的继承关系，必须满足 ”is a” 的关系。
继承是在一组相同的类或似的的类中，抽取出共性的特征和行为，定义在父类中，实现重用。
产生继承关系之后，子类可以使用父类中的属性和方法，也可以定义子类独有的属性和方法。

public class TestAnimal {

	public static void main(String[] args) {
		Dog d=new Dog();
		d.color="黄色";
		d.setAge(2);
		d.setName("小花");
		d.eat();
	}
}

class Animal{
	String color;
	public void eat() {
		System.out.println(color+"颜色的小狗在吃东西");
	}	
}
	
class Dog extends Animal{
	private String  name;
	private int age;
	public Dog() {}
	public Dog(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	public void eat() {
		System.out.println("名字为"+this.name+"的"+color+"小狗今年"+this.age+"岁了，现在正在吃东西");
	}	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}

不可继承的情况：
1.构造方法：类中的构造方法，只负责创建本类的对象，不被继承

2.Private 修饰的属性和方法：仅本类可见，不可继承

3.父子不在同一个package, default修饰的属性和方法，不被继承

注意：Java为单继承，一个类只能有一个直接父类，但可以多级继承，属性和方法逐 级叠加

当父类提供的方法无法满足子类的需求时，可以在子类中定义和父类相同的方法，进行覆盖。调用时优先执行子类覆盖后的方法。

在子类中，可直接访问从父类继承到的属性和方法，但父子类的属性或方法存在重名（属性遮蔽、方法覆盖）时，要加以区分来访问，此时会用到***super关键字***

1. 第一种用法：
   在子类中，可以通过" super. "的形式访问父类的属性和方法，可解决一定的属性遮蔽、方法覆盖后的父类成员调用问题；可以叠加额外功能代码，组成新的功能
   2.第二种用法：
   super() 表示在子类构造方法的首行，调用父类的无参构造方法: super(实参)调用父类的有参构造方法

3.多态

父类引用指向子类对象，从而产生多种形态。构成多态的前提，二者之间必须具有直接或间接的继承关系，父类引用可指向子类对象，进而形成多态，父类引用仅可调用父类中所声明的属性和方法，不可调用子类独有的属性和方法。
有两种使用方法：
1.使用父类作为方法形参实现多态，使方法参数的类型更为宽泛。调用方法时，可以传递的实参类型包括：本类型对象+其所有子类对象
2.使用父类作为方法返回值实现多态，使方法可以返回不同子类对象。调用方法后，可得到的结果类型包括：本类型对象+其所有子类对象。

public class TestApplyPolymorphic {
	public static void main(String[] args) {
		Bus bus = new Bus();
		bus.type = "公交车";
		bus.speed = 40;
		bus.price = 1000000.0;
		bus.seatNum = 20;
		
		Bicycle bic = new Bicycle();
		bic.type = "自行车";
		bic.speed = 20;
		bic.price = 2000.0;
		bic.color = "红色";
		
		Employee emp = new Employee();//员工对象
		emp.name = "tom";
		emp.goHome(bus);
		emp.goHome(bic);
			
		//调用员工买车的方法（新）
		Employee emp2 = new Employee();
		emp2.name = "jack";
		Vehicle myVehicle = emp2.buyVehicle(3);// input.nextInt()  用户录入金额
		if(myVehicle !=null) {
			emp2.goHome(myVehicle);
		}else {
			System.out.println("钱不够，没买成....  -_-");
		}
		
		//拆箱：将父类引用中的真实子类对象，转回成其本身类型
		if( myVehicle  instanceof Car ) {//判断myVehicle引用中的真实子类对象，是否为Car类型
			Car myCar = (Car)myVehicle;
			System.out.println(myCar.brand);
		}else if(myVehicle instanceof Bus) {
			Bus myBus = (Bus)myVehicle;
			System.out.println(myBus.seatNum);
		}else if(myVehicle instanceof Bicycle) {
			Bicycle myBicycle = (Bicycle)myVehicle;
			System.out.println(myBicycle.color);
		}
		
	}

}

//员工
class Employee{//Employee.java ---> Employee.class
	String name;
	
	//回家（父类类型作为方法形参，实现多态）
	public void goHome(Vehicle veh) {//Vehicle veh = new Bus()
		System.out.print(name +"正在乘坐");
		veh.run();
	}
	
	//员工买车（新）
	public Vehicle buyVehicle(int money) {//单位：万
		
		Vehicle veh = null;//方法返回值
		
		if(money >= 100) {
			//买一辆公交车
			Bus bus = new Bus();
			bus.type = "公交车";
			bus.speed = 50;
			bus.price = 1100000.0;
			bus.seatNum = 16;
			veh = bus;
		}else if(money >= 30) {
			//买一辆小汽车
			Car car = new Car();
			car.type = "小汽车";
			car.speed = 90;
			car.price = 300100.0;
			car.brand = "Benz";
			veh = car;
		}else if(money >= 2) {
			//买一辆自行车
			Bicycle bic = new Bicycle();
			bic.type = "自行车";
			bic.speed = 30;
			bic.price = 2100.0;
			bic.color = "黑色";
			veh = bic;
		}
		
		return veh;
	}
}

class Vehicle{
	String type;//公交车、小汽车、自行车
	int speed;
	double price;
	
	public void run() {
		System.out.println("一辆价值"+price+"RMB的"+type+"正在以"+speed+"/H速度前进......");
	}
}

class Car extends Vehicle{
	String brand;
	
	public void run() {
		System.out.println("一辆价值"+price+"RMB的"+brand+"品牌的"+type+"正在以"+speed+"/H速度前进......");
	}
}

class Bus extends Vehicle{
	int seatNum;
	
	public void run() {
		System.out.println("一辆价值"+price+"RMB的"+seatNum+"个座位的"+type+"正在以"+speed+"/H速度前进......");
	}
}

class Bicycle extends Vehicle{
	String color;
	
	public void run() {
		System.out.println("一辆价值"+price+"RMB的"+color+"的"+type+"正在以"+speed+"/H速度前进......");
	}
}

class Train extends Vehicle{}