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();
}
}


竣工、、、