继承

1:代码块是什么?代码块的分类和各自特点?

      代码块是方法

2:静态代码块,构造代码块,构造方法的执行流程?

   静态—>构造代码块--->构造方法

3:继承概述

 通过extends 关键字，可以实现类与类的继承

 

4:继承的好处

 代码复用(偷懒)

5:Java中继承的特点

单继承: 一个类 只能继承 一个类，不用同事继承两个以上的类

6:Java中继承的注意事项?以及我们什么时候使用继承?

A . 子类只能继承父类所有非私有的成员（成员方法和成员变量）private 不能击沉

B .子类不能继承父类的构造方法，但是可以通过super关键字去访问

C. 不能为了部分功能去继承

7:继承中的成员访问特点

A:成员变量

在子类方法中访问一个变量

         This.成员变量

         Super.成员变量

B:成员方法

在测试类中通过子类对象去访问一个方法

          This.成员方法

          Super.成员方法

8:继承中构造方法的执行流程?假如父类没有无参构造方法，子类应该怎么办?

子类用  super  去访问

9:面试题：

方法重写和方法重载的区别?方法重载能改变返回值类型吗?

Overload ： 方法重载--->  本类中，方法名相同，参数列表不同， 与返回值无关

Override ：方法重写 --->  子类和父类的声明方法一模一样,子类覆盖父类的方法

 

this关键字和super关键字分别代表什么?以及他们各自的使用场景和作用。

10:继承案例练习

      This.表示本类。(当前对象)

      Super.表示父类 (父类存储空间的引用)

 

动物 {

姓名,年龄,腿的个数

构造方法

get()/set()

睡觉();

吃();

 

} 

猫{

姓名,年龄,腿的个数

构造方法

get()/set()

睡觉();

吃(); //吃鱼

}

狗{

姓名,年龄,腿的个数

构造方法

get()/set()

睡觉();

吃(); //吃骨头

}

 

 

 

 

 

 

package Dongwu;

//动物类的

public class DongWu {

    private String name ;  //姓名

    private int age ;  //年龄

    private String color ; //颜色

    

    DongWu (){}

    

    DongWu(String name ,int age ,String color){

    this.name = name ;

    this.age  =age ;

    this .color = color ;

    } 

   

    

    

    public void setName(String name ){

    this. name =name ;

    }

    public String getName(){

    return name ;

    }

    

    

    public void setAge (int age ){

    this.age = age ;    

    }

    public int getAge (){

    return age ;

    }

    

    

    public void setColor (String color ){

    this.color =color ;

    }

    public String getColor (){

    return color ;

    }

    

    public void eat (){

    System.out.println("可爱的动物们啊，不要睡觉了， 该吃饭了啊");

    }

    

    }

    

 

package Dongwu;

 

public class Gou extends Mao {

    Gou(){}

    Gou(String name ,int age ,String color){

    super(name,age,color);

    }

    public void GouWan(){

    System.out.println("史敏玩狗");

    }

}

 

 

 

package Dongwu;

 

public class Mao extends DongWu{

   Mao(){}

   

   Mao(String name ,int age ,String color){

 super (name,age,color);

   }

   public void MaoWan(){

   System.out.println("猫-玩-我-贾哥...");

   }

   

}

 

package Dongwu;

 

public class Diao {

public static void main(String[] args) {

 Mao m = new Mao();

 m.MaoWan();

 

 m.setAge(32);

 m.setColor("白色");

 m.setName("猫叔");

 

 System.out.println("猫的名字是："+m.getName()+"\n"+"猫的年龄是"+m.getAge()+"\n"+"猫的颜色是："+m.getColor());

 

 

 Gou g  =new Gou(){};

 g.GouWan();

 

 g.setAge(200);

 g.setName("波比");

 g.setColor("白加黑");

 

 System.out.println("狗的名字是："+g.getName()+"  "+"狗的年龄： "+g.getAge() +"  "+ "狗的颜色： "+ g.getColor());

 

 

 

}

 

}

 

 

 

11:final关键字可以干什么?有什么特点?

   可以修饰方法，类，变量。

   特点：被修饰的不能被子类所覆盖。 Final 会被绝育，不会在有子类。

 

 

 

 

12:final关键字的面试题?

A:修饰局部变量,能够被更改么?

   基本数据类型：值不能被改变！

    引用数据类型：地址值不能被改变

B:在什么时候可以初始化?

     在对象构建完毕就OK了

 

 

Test2--【熟】假如我们在开发一个系统时需要对员工进行建模，【员工】包含 3 个属性：姓名、工号以及工资。 【经理】也是员工，除了含有员工的属性外，另为还有一个奖金属性。请使用继承的思想设计出员工类和经理类。要求类中提供必要的方法进行属性访问。

 

public class ShuXing {

String name ; //姓名

int moeny  ;  //薪资

String Yname;

ShuXing(){}

ShuXing(String name,int moeny,String Yname){

this.name =name ;

this.moeny =moeny;

this.Yname =Yname;

}

public void setName(String name){

this.name =name;

}

public String getName (){

return this.name ;

}

public void setMoeny(int moeny){

this.moeny =moeny;

}

public int getMoeny (){

return this.moeny ;

}

public void setYname(String Yname){

this.Yname =Yname;

}

public String getYname (){

return this.Yname ;

}

public void show(){

System.out.println("发工资啦...");

}

}

 

 

package app;

 

public class JingLi extends ShuXing {

  JingLi(){}

  JingLi(String name,int moeny ,String Yname){

  super (name,moeny,Yname);

  }

       public void Jzi(){

       System.out.println("经理要发工资啦....");

       }

      

 

}

 

 

package app;

 

public class YuanGong extends JingLi {

YuanGong (){}

YuanGong(String name ,int moeny ,String Yname){

super (name,moeny ,Yname);

}

  public void Yg(){

   System.out.println("月下苍腾思井空....");

  }

}

 

 

 

public class MM {

  public static void main(String[] args) {

   JingLi  j = new JingLi();

   j.setName("史敏");

   j.setMoeny(70000);

   j.setYname(" ");

   j.Jzi();

   

   

   System.out.println("管理层（经理）："+j.getName()+"\n "+" 薪资是："+j.getMoeny()+j.getYname());

 

   System.out.println("----------------------------------------------");

   YuanGong y = new YuanGong ();

    y.setMoeny(100000);

   y.setYname("贾喜");

   y.Yg();

   

   System.out.println("员工层是："+y.getYname()+" 薪资："+y.getMoeny()+"祝哥月薪百万");

  

   

}

}

 

Final 可以修饰方法，类，变量 

特点：

Fianl 可以修饰类 ， 该类不能被继承

          可以修饰方法，该方法不能被继承

          可以修饰成员变量  ，该变量不能被重新赋值，因为这个变量为常量

 

 

 

常量：

 

  字面值常量：

“hello”  ,10 , ture,

 

自定义常量

  Final int x = 10;

被final 修饰之后就是自定义常量

 

总结：  被final 修饰的东西不能被更改(它是最终的意思)

 

 

 

面试题：

  Final  修饰局部变量的问题

 

   基本数据类型：

        值不能被改变

 

 引用数据类型

   地址值不能被改变