java 继承 父类也会有子类方法吗 java继承父类的属性

继承：

类关系：继承是两个类存在is-a的关系，例如，经理 is a 雇员

关键字：继承使用extends关键字 例如 class A extends B

为什么继承：代码复用，可以对父类进行扩展，对父类方法进行重写

子类继承父类可以继承什么：子类继承父类非private 的属性和方法（不是构造方法），但是却可以通过get,set方法使用父类private的属性

下面通过例子说明：

public class ExtendsStudy{
 public static void main(String[] args) {
 //创建了一个经理，但是Manager不能直接的设置name和salery，因为是父类私有得属性 Manager m=new Manager();

 
 //此处可以使用公开得set方法进行设置name 

 m.setName("经理"); 

 m.setSalery(11); 

 m.setBonus(12); 

 Employe e=new Employe();

 //e.setBonus(12);   //此行代码报错，因为雇员类没有奖金这个属性，Bonus是经理特有得属性

 
 //通过子类进行父类得方法调用，继承到了飞priavet的方法 

 int salery=m.getSalery(); 

 } 

} 

//雇员类 

class Employe{ 

 private String name; 

 //薪水 

 private int salery; 

 public String getName() { 

 return name; 

 } 

 public void setName(String name) { 

 this.name = name; 

 } 

 public int getSalery() { 

 return salery; 

 } 

 public void setSalery(int salery) { 

 this.salery = salery; 

 } 



} 

//经理类 

class Manager extends Employe{ 

 //奖金 

 private int bonus; 

 public int getBonus() { 

 return bonus; 

 } 

 public void setBonus(int bonus) { 

 this.bonus = bonus; 

 } 

}

因为经理得薪水是由“薪水”+"奖金"构成，所以父类得获取薪水得方法对子类不适用，因此需要进行扩展，也就是方法得重写

public class ExtendsStudy{
 public static void main(String[] args) {
 Manager m=new Manager();
 m.setSalery(12);//设置工资
 m.setName("经理");//设置名称
 m.setBonus(11);//设置奖金
 
 //打印经理得总薪水 输出结果为：23
 //很明显，m调用的getSalery方法是子类中得方法，而不是父类的方法
 //用友继承关系的子类方法调用，回先再子类中找此方法，如果有则直接调用，如果没有则去父类中找
 System.out.println(m.getSalery());
 }
}

//雇员类
class Employe{
 private String name;
 //薪水
 private int salery;


 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
 public int getSalery() {
 return salery;
 }
 public void setSalery(int salery) {
 this.salery = salery;
 }


}
//经理类
class Manager extends Employe{
 //奖金
 private int bonus;


 public int getBonus() {
 return bonus;
 }


 public void setBonus(int bonus) {
 this.bonus = bonus;
 }
 //对经理获取薪水得方法进行重写,获取重新计算薪水得方法
 @Override
 public int getSalery(){
 int sal=super.getSalery();
 return sal+this.bonus;
 }
 
}

不能继承父类得构造方法：

public class ExtendsStudy{
 public static void main(String[] args) {
 Manager m=new Manager();
 //直接运行，打印出：”父类无参构造函数，子类无参构造函数“
 //说明子类无参构造函数在使用得时候会先执行父类无参构造函数，然后再调用子类得构造函数
 
 //运行打印出：”父类无参构造函数 子类有参构造函数“
 //说明：子类调用有参构造函数时，同样是先调用父类无参构造函数，那么如果父类没有无参构造函数呢？
 Manager m1=new Manager(1);
 }
}


//雇员类
class Employe{
 private String name;
 //薪水
 private int salery;


 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
 public int getSalery() {
 return salery;
 }
 public void setSalery(int salery) {
 this.salery = salery;
 }
 public Employe() {
 super();
 System.out.println("父类无参构造函数");
 }
 


}
//经理类
class Manager extends Employe{
 //奖金
 private int bonus;


 public int getBonus() {
 return bonus;
 }


 public void setBonus(int bonus) {
 this.bonus = bonus;
 }
 //对经理获取薪水得方法进行重写,获取重新计算薪水得方法
 @Override
 public int getSalery(){
 int sal=super.getSalery();
 return sal+this.bonus;
 }
 //子类有参构造函数
 public Manager(int bonus) {
 System.out.println("子类有参构造函数");
 this.bonus = bonus;
 }
 //子类无参构造函数
 public Manager() {
 System.out.println("子类无参构造函数");
 }
}

 

如果父类不提供无参构造函数会怎么样：

将上面得雇员类修改为：
//雇员类
class Employe{
 private String name;
 //薪水
 private int salery;


 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
 public int getSalery() {
 return salery;
 }
 public void setSalery(int salery) {
 this.salery = salery;
 }
 public Employe(String name, int salery) {
 super();
 this.name = name;
 this.salery = salery;
 }}

子类构造函数直接报错：这时需要在子类构造函数中手动调用父类有参构造函数。

针对继承操作不得不说说super关键字，例如：

//对经理获取薪水得方法进行重写,获取重新计算薪水得方法
 @Override
 public int getSalery(){
 int sal=super.getSalery();
 return sal+this.bonus; }

        此处如果不加入super，那么回直接调用子类得getSalery方法，进入死循环。super说明得是父类得getSalery方法

this与super

this是当前类得引用，代表得是当前类，可以直接object=this ,使用的时候可以直接this.field和this.method进行调用，

super指向得是父类，object=super是不成立得，super只是指向父类方法，而不是父类的引用.使用的时候super.constructor和

this.method进行调用

多态：

public class ExtendsStudy{
 public static void main(String[] args) {
 Manager m1=new Manager();
 m1.setName("经理");
 m1.setBonus(11);
 m1.setSalery(12);
 Employe e1=new Employe("小黑", 20);
 Employe e2=new Employe("小红", 30);
 Employe [] es=new Employe[3];
 es[0]=m1;
 es[1]=e1;
 es[2]=e2;
 
 for(int i=0;i<es.length;i++){
 System.out.println(es[i].getName()+"的薪资为"+es[i].getSalery());
 }
 //结果为：
 //经理的薪资为23
 //小黑的薪资为20
 //小红的薪资为30
 
 //说明：经理得薪资计算方法是子类中得方法，小黑与小红得薪资是父类得方法
 //当Employe对象在调用getSalery方法得时候，知道当前对象引用得是哪个类型得对象
 //一个对象变量可以引用多个对象得现象称之为”多态“
 //再运行时能够动态得选择哪个方法得调用，称之为”动态绑定“
 
 }
}


//雇员类
class Employe{
 private String name;
 //薪水
 private int salery;


 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 }
 public int getSalery() {
 return salery;
 }
 public void setSalery(int salery) {
 this.salery = salery;
 }
 public Employe(String name, int salery) {
 super();
 this.name = name;
 this.salery = salery;
 }
 public Employe() {
 super();
 }
 
 


}
//经理类
class Manager extends Employe{
 //奖金
 private int bonus;


 public int getBonus() {
 return bonus;
 }


 public void setBonus(int bonus) {
 this.bonus = bonus;
 }
 //对经理获取薪水得方法进行重写,获取重新计算薪水得方法
 @Override
 public int getSalery(){
 int sal=super.getSalery();
 return sal+this.bonus;
 }
 //子类有参构造函数
 public Manager(int bonus) {
 System.out.println("子类有参构造函数");
 this.bonus = bonus;
 }
 //子类无参构造函数
 public Manager() {
 System.out.println("子类无参构造函数");
 }
}