java基础--关于封装、继承、重写与多态

面向对象的特性在很早以前有四个，但现在大都说以下三个特性：封装、继承、多态。

下面分别说说这三个特性：

1.封装：通俗的定义就是将一个类包装起来

      但包装的作用是什么呢？

      隐藏属性，将类的某些信息隐藏，使外部类不能直接访问（保密作用）

它使得属性私有化，我们需要用set和get的方法去使用它。

例如：这个public类型的存钱方法--任何人都可以去访问调用和使用它，显然这不是我们愿意的，所以我们就需要将这个方法进行隐藏。那么此时就需要用到封装了

public void deposit1() {

		double money;
		System.out.println("你想存多少钱：");
		double m = scanner.nextDouble();
		if (m < 0) {
			System.out.println("你是猪！");
			System.exit(0);
		} else {
			this.money += m;
			System.out.println("取钱成功，卡内余额：" + this.money);
		}
	}

改进：将deposit1()变成私有的方法，用一个public 类型的deposit()方法去调用，这样我们去查看那个public deposit()方法时，就什么也发现不了，这就达到了隐藏的目的

public void deposit() {
		deposit1();
	}

	private void deposit1() {

		double money;
		System.out.println("你想存多少钱：");
		double m = scanner.nextDouble();
		if (m < 0) {
			System.out.println("你是猪！");
			System.exit(0);
		} else {
			this.money += m;
			System.out.println("取钱成功，卡内余额：" + this.money);
		}
	}

2.继承(extend)：从已有的类派生出新的，新的类可以使用已有的类的东西，还可以使用自己的东西
       优点：代码的复用

       特点：继承是单向的--通俗的将：一个人有且只有一个亲爹，但他的亲爹却可能不止他一个儿子（理解就行、、、）

被继承的称作父类（超类），继承者成为子类

例如：

父类A：

public class A{
String name；
pubic void eat(){
System.out.println("这是父类的eat方法");
}
}

子类B：

public class B extends A{
	
}

测试类：

public class Test {
 
	public static void main(String[] args) {

		B b=new B();

		b.name="dog";

		b.eat();

}

显然子类B里面没有定义任何参数和方法，但对象b却依然可以顺利的调用参数name和方法eat(),正是因为他的父类是A，B顺利的继承了A的所有属性和方法

3.访问范围 空 public  private  protected
空：默认访问权限是同一个包内
public：所有的地方都可以直接访问
private：本类内可以直接访问
protected：同包+跨包的子类可以直接访问

4.重写（覆盖）---继承之后从新改写父类的方法  关键字：@Override--检测重写方法
特点：发生在父子类中
 方法名相同，参数列表相同（称之为方法签名相同）
 子类访问权限修饰符不能小于父类
 子类重写的方法

，不能抛出比父类更多更大的异常
 对于返回值，分两种情况：1.如果父类的方法返回值是一个基本的数据类型，子类重写的方法返回值与父类定义的方法返回值要一样

      2.如果父类的方法返回值是一个对象类型，子类重写的方法返回值是父类的定义的方法返回值类型或其子类（返回类型协变）

例如：

父类：

public class Shap {
public String toString(){
return "";
	}
}

子类：--同时写了get和set的方法

  --注意关键字@Override

  --注意父类的toString（）方法和子类的toString()方法

public class Circle extends Shap {
	private double r;//半径
	
	public double getR() {
		return r;
	}

	public void setR(double r) {
		this.r = r;
	}

	public Circle(double r) {
		super();
		this.r = r;
	}	
	
	@Override
	public String toString() {
		System.out.println(Math.PI*r*2);
		return "";
	}}

5.多态 相同的消息发给不同的对象，得到的是不同的结果。

让代码书写更简短

训练：写一个关于薪资的多态问题

父类：

public class Employee {
	private String name;
	private int month;
	private double slary;

	public Employee(String name, int month, double slary) {
		super();
		this.name = name;
		this.month = month;
		this.slary = slary;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getMonth() {
		return month;
	}

	public void setMonth(int month) {
		this.month = month;
	}

	public double getSlary() {
		return slary;
	}

	public void setSlary(double slary) {
		this.slary = slary;
	}

	public void show() {

	}
}

子类1：

public class HourlyEmployee extends Employee {
	public HourlyEmployee(String name, int month, double slary) {
		super(name, month, slary);
	}

	private int hours;
	private int hoursslary;
	private double yuegongzi;

	

	public int getHours() {
		return hours;
	}

	public void setHours(int hours) {
		this.hours = hours;
	}

	public int getHoursslary() {
		return hoursslary;
	}

	public void setHoursslary(int hoursslary) {
		this.hoursslary = hoursslary;
	}

	public double getYuegongzi() {
		return yuegongzi;
	}

	public void setYuegongzi(double yuegongzi) {
		this.yuegongzi = yuegongzi;
	}

	private void show1(int hours,int hoursslary) {
		if (hours > 160) {
			yuegongzi = 160 * hoursslary + hoursslary * (hours - 160) * 1.5;
			System.out.println(getName()+":\t小时工\t\t生日为："+getMonth()+"月\t月薪为：" +getYuegongzi());
		} else {
			yuegongzi = hours * hoursslary;
			System.out.println(getName()+":小时工，生日为："+getMonth()+"干"+hours+"小时的工资为：" +getYuegongzi());
		}

	}

	public void show() {
		show1(170,300);
	}
}

子类2

public class SalesEmployee extends Employee {
	public SalesEmployee(String name, int month, double slary) {
		super(name, month, slary);
	}

	private int sales;
	private double tichenglv;
	

	public int getSales() {
		return sales;
	}

	public void setSales(int sales) {
		this.sales = sales;
	}

	public double getTichenglv() {
		return tichenglv;
	}

	public void setTichenglv(double tichenglv) {
		this.tichenglv = tichenglv;
	}

	private void show1(int sales,double tichenglv) {
		System.out.println(getName()+":\t销售人员\t生日为："+getMonth() +"月\t月薪为："+sales * tichenglv);
	}

	public void show() {
		show1(10000,6);
	}
}

子类3

public class SlariedEmployee extends Employee {

	

	public SlariedEmployee(String name, int month, double slary) {
		super(name, month, slary);
	}

	private void show1(int month) {
		if (month==7) {
			System.out.println(getName()+":\t固定工资\t生日是："+getMonth()+"月\t月薪是：" + (getSlary()+100));
		}

	}

	public void show() {
		show1(7);
	}

}

子类4

public class SlariedEmployee extends Employee {

	

	public SlariedEmployee(String name, int month, double slary) {
		super(name, month, slary);
	}

	private void show1(int month) {
		if (month==7) {
			System.out.println(getName()+":\t固定工资\t生日是："+getMonth()+"月\t月薪是：" + (getSlary()+100));
		}

	}

	public void show() {
		show1(7);
	}

}

子类5

public class BasePlusSalesEmployee extends SalesEmployee {

	public BasePlusSalesEmployee(String name, int month, double slary) {
		super(name, month, slary);
	}
	private void show1(int sales,double tichenglv) {
		System.out.println(getName()+":\t固定底薪\t生日为："+getMonth()+"月\t月薪为："
				+ (getSlary() + sales * tichenglv));
	}
	public void show() {
		show1(1000,3);
	}
}

测试类：

public class TestEmployee {

	public static void main(String[] args) {
		Employee[] employee=new Employee[4];
		employee[0]=new SlariedEmployee("仝尧",7,50000);
		employee[1]=new HourlyEmployee("巧姐",8,50000);
		employee[2]=new SalesEmployee("杰哥",9,0);
		employee[3]=new BasePlusSalesEmployee("峰姐",10,50000);
		employee[0].show();
		employee[1].show();
		employee[2].show();
		employee[3].show();	
	}
}

竣工、、、