继承性、方法的重写

Java面向对象学习day12

不要人夸颜色好，只留清气满乾坤。

一、继承性

1、继承性的好处：

• 减少了代码的冗余，提高了代码的复用性。

• 便于功能的扩展

• 为多态的使用，提供了前提

2、继承性的格式：

class A extends B { }

A ： 子类、派生类、subclass

B ：父类、超类、基类、superclass

3、继承性的说明：

3.1 体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的结构：所有的属性、方法

特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只是因为封装性的影响，使得子类不能直接调用父类的结构而已。

3.2 子类继承父类以后，还可以声明自己特有的属性和方法：实现功能的扩展。

子类和父类的关系，不同于子集和集合的关系。

extends：延展、扩展

4、继承性的规定：

• 一个类可以被多个子类继承。

• Java中类的单继承性：一个类只能有一个父类

• 子父类是相对的概念。

• 子类直接继承的父类，成为：直接父类。间接继承的父类称为：间接父类

• 子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法。

 

5、快捷键：

IDEA里 ctrl + h ，可以查看类之间的继承关系。

 

注：h为Hierarchy（层次）的缩写

6、Object类

1. 如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类

2. 所有的java类（除了java.lang.Object类之外）都直接或间接继承于java.lang.Object类

3. 意味着，所有的java类具有java.lang.Object类声明的功能。

4. Object类可以理解为一棵树的根节点

二、方法的重写

（override/overwrite）（覆盖）

1、说明：

• 重写：子类继承父类以后，可以对父类中同名同参数的方法，进行覆盖操作

• 应用：重写以后，当创建子类对象以后，通过子类对象调用父类中同名同参数的方法时，实际执行的是子类重写父类的方法。

• 面试题：区分方法的重载与重写

2、重写的规定：

约定俗称：子类中的叫重写的方法，父类中的叫被重写的方法

2.1 方法名与形参列表

子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同（唯一定位）

2.2 权限修饰符：

• 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符

• 特殊情况：子类不能重写父类中声明为private权限的方法

2.3 返回值类型：

• 父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型也只能是void

• 父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类（Object ---> String）

• 父类被重写的方法的返回值类型是基本数据类型，则子类重写的方法的返回值类型必须是相同的基本数据类型。（double ---> 必须也是double）

• 子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型(Exception ---> Runtime )

• *子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static（不是重写）

3、实例

Person类：

package Object.day12.override;
 ​
 public class Person {
 ​
     String name;
     int age;
 ​
     public Person(){
 ​
     }
     public Person(String name,int age){
         this.name = name;
         this.age = age;
     }
 ​
     public void eat(){
         System.out.println("吃饭");
     }
     public void walk(int distance){
         System.out.println("走路,走的距离为" + distance + "公里" );
         show();
         eat();
     }
 ​
     private void show(){
         System.out.println("我是一个人");
     }
 }

Student类；

package Object.day12.override;
 ​
 public class Student extends Person{
 ​
     String major;
 ​
     public Student(){
 ​
     }
     public Student(String major){
         this.major = major;
     }
 ​
     public void study(){
         System.out.println("学习，专业是：" + major);
     }
 ​
     public void eat(){
         System.out.println("我好想吃饭啊~");
     }
 ​
     public void show(){
         System.out.println("我是一个学生");
     }
 ​
     @Override
     public void walk(int distance) {
         System.out.println("重写方法啦");
     }
 }

PersonTest类：

package Object.day12.override;
 ​
 public class PersonTest {
     public static void main(String[] args) {
 ​
         Student s = new Student("软件工程");
 ​
         s.eat();
         s.walk(12);
         System.out.println("=========================");
         s.study();
 ​
         Person p = new Person();
         p.eat();
     }
 }

 

三、Test

Test1

1、题目：

 

2、代码：

Mankind类：

package Object.day12.Test;
 ​
 public class ManKind {
     private int sex;
     private int salary;
 ​
     public ManKind(){
 ​
     }
     public ManKind(int sex,int salary){
         this.sex = sex;
         this.salary = salary;
     }
 ​
     public int getSex(){
         return sex;
     }
     public void setSex(int sex){
         this.sex = sex;
     }
 ​
     public int getSalary(){
         return salary;
     }
     public void setSalary(int salary){
         this.salary = salary;
     }
 ​
     public void manOrWoman(int sex){
         if(sex == 1){
             System.out.println("man");
         }else if(sex == 0){
             System.out.println("woman");
         }
     }
 ​
     public void employeed(int salary){
 //        if(salary == 0){
 //            System.out.println("no job");
 //        }else{
 //            System.out.println("job");
 //        }
         String hasjob = (salary == 0) ? "no job " : "job";
         System.out.println(hasjob);
     }
 }

Kid类：

package Object.day12.Test;
 ​
 public class Kids extends ManKind{
 ​
     private int yearsOld;
 ​
     public Kids(){
 ​
     }
     public Kids(int yearsOld){
         this.yearsOld = yearsOld;
     }
 ​
     public int getYearsOld(){
         return yearsOld;
     }
     public void setYearsOld(int yearsOld){
         this.yearsOld = yearsOld;
     }
 ​
     public void printAge(){
         System.out.println(yearsOld);
     }
 ​
 ​
 }

KidsTest类：

 package Object.day12.Test;
 ​
 public class KidsTest {
     public static void main(String[] args) {
         Kids someKid = new Kids();
         someKid.setSex(13);
         System.out.println(someKid.getSex());
         someKid.setSalary(4444);
         System.out.println(someKid.getSalary());
         someKid.manOrWoman(1);
     }
 }

3、运行结果：

 

Test2

1、题目：

 

2、代码：

Circle类：

package Object.day12.Test.Test2;
 ​
 public class Circle {
     private double radius;
     public Circle(){
         this.radius = 1.0;
     }
     public Circle(double radius){
         this.radius = radius;
     }
 ​
     public void setRadius(double radius){
         this.radius = radius;
     }
     public double getRadius(){
         return radius;
     }
 ​
     public double findArea(){
         return Math.PI * Math.PI *radius;
     }
 }

Cylinder类：

package Object.day12.Test.Test2;
 ​
 public class Cylinder extends Circle{
 ​
     private double length;
 ​
     public Cylinder(){
         this.length = 1.0;
     }
     public Cylinder(double length){
         this.length = length;
     }
 ​
     public void setLength(double length){
         this.length = length;
     }
     public double getLength(){
         return length;
     }
 ​
     public double findVolume(){
         return findArea() * length;
     }
 ​
 }

CylinderTest类：

package Object.day12.Test.Test2;
 ​
 public class CylinderTest {
     public static void main(String[] args) {
 ​
         Cylinder cylinder = new Cylinder();
 ​
         cylinder.setRadius(2.0);
         cylinder.setLength(3.0);
         System.out.println("圆柱的底面半径为："+ cylinder.getRadius()+ "     圆柱的高为："+ cylinder.getLength());
         System.out.println("圆柱体积为：" + cylinder.findVolume());
     }
 }

3、运行结果：