1

java之继承精选

 1 year ago
source link: https://blog.51cto.com/JavaArchitect/5592552
Go to the source link to view the article. You can view the picture content, updated content and better typesetting reading experience. If the link is broken, please click the button below to view the snapshot at that time.

java之继承精选

推荐 原创

我们上一篇讲的是java封装，这一篇我们聊一下继承，继承我们可以理解：比如可以先定义一个类叫车，车有以下属性：车体大小，颜色，方向盘，轮胎，而又由车这个类派生出轿车和卡车两个类，为轿车添加一个小后备箱，而为卡车添加一个大货箱，那这个就是继承的派系，我们简单理解，直接往下看~

java之继承精选_概念

     继承是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。

     在面向对象程序设计中运用继承原则，就是在每个由一般类和特殊类形成的一般——特殊结构中，把一般类的对象实例和所有特殊类的对象实例都共同具有的属性和操作一次性地在一般类中进行显式的定义，在特殊类中不再重复地定义一般类中已经定义的东西，但是在语义上，特殊类却自动地、隐含地拥有它的一般类(以及所有更上层的一般类)中定义的属性和操作。

特殊类的对象拥有其一般类的全部或部分属性与方法，称作特殊类对一般类的继承。

二．知识点介绍

    2、定义及使用格式

    3、继承注意事项

    4、方法重写

三．知识点详解

1、继承概念

1.1、继承概述 

    继承是面向对象的核心特性，是面向对象的学习重点。同时继承是代码复用的重要方式，可以表示类与类之间的关系，是所有面向对象语言不可缺少的组成部分。

1.2、继承概念

    当一个类的属性与行为均与现有类相似，属于现有类的一种时，这一个类可以定义为现有类的子类。

    或者换成相反的角度来看，如果多个类具有相同的属性和行为，我们可以抽取出共性的内容定义父类，这时再创建相似的类时只要继承父类即可。

    子类拥有父类的所有属性与方法，无需重新定义。并且可以直接使用非私有的父类成员。

    从类与类之间的设计关系来看,子类必须属于父类的一种时，才会继承。

    我们在完成一个庞大项目体系的时候，都是将共性的内容抽取出，后续构建过程是从各种父类“向外”扩散的。

    下例展示了一个继承关系

java之继承精选_代码_02

                                         动物继承关系图

     动物类可以有姓名、年龄的成员变量，可以有吃饭、睡觉的方法。

    所有猫科与犬科均有动物的成员变量与成员方法，且猫科与犬科均属于动物，所以猫科与全科均可以继承动物类。

    猫科可以在动物的基础上再添加抓老鼠的方法

    犬科可以在动物的基础上再添加看门的方法

    犬科与猫科仍可以继续出现子类，如波斯猫、巴厘猫、沙皮狗、斑点狗等，而其子类仍可以再出现该品种的特性。

2、继承定义及使用格式

2.1、继承定义

class 子类 extends 父类{

//父类的非私有方法与属性均继承过来
    }


    //如：父类的定义：
    class Person{
     private String name;

public void eat(){
    System.out.println(“吃饭”);
       }
      // get/set方法
       }

//  子类继承父类的定义：
   class Chinese extends Person{


   }



2.2、继承使用



    继承关系的产生通常是为了定义出功能更为具体、更为强大的子类。所以，定义子类后，一般创建子类对象使用。子类可以直接使用父类非私有的成员变量与成员方法(注：如果成员变量没有使用private修饰，则子类也可直接访问。)



子类代码演示：



package com.Test;


class Test{

//子类
   static class Chinese {

String name;

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

public String getName() {
           return name;
       }
      //子类方法
        public void eat(){
            System.out.println("吃饭");
        }

}
   //主方法调用
    public static void main(String[] args) {
        Chinese c = new Chinese();
        c.setName("磊哥的java历险记");
        String name = c.getName();
        //打印结果为磊哥的java历险记
        System.out.println(name);
        //打印结果吃饭
        c.eat();
    }
}



java之继承精选_代码_03



3、继承注意事项 



    Java只支持单继承，不支持多继承。即只能有一个父类。



    父类可以继续有父类。



    所有类均有父类，只有Object类没有父类。



    在所有使用父类类型的地方均可以传入其子类对象。



代码演示：



package com.Test;


/*

Animal的类
       属性：name，age
       行为：吃，睡

*/
    //动物
class Animal {
    //成员变量
    private String name;
    private int age;

//吃
    public  void eat(){
    System.out.println("吃饭");
      }
    //睡
    public void sleep(){
        System.out.println("睡觉");
    }
    //-----------get/set-------------------
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}
    /*
     *定义一个猫类
     * 属性
     * 行为
     *  吃
     *  睡
     *  抓老鼠

*/
    //猫继承动物类
 class Cat extends Animal{

private String kind;

public void eat(){
      System.out.println("猫吃鱼");
     }

//猫特有的功能  抓老鼠
    public void catchMouse(){
       System.out.println("抓耗子");
    }

public String getKind() {
       return kind;
    }
    public void setKind(String kind) {
       this.kind = kind;
    }
}
/*
 *定义一个狗类
 * 属性
 * 行为
 *  吃
 *  睡
 *  看门
 *
 */
    //狗继承动物类
  class Dog extends Animal{
    private String kind;

public void eat(){
      System.out.println("狗吃肉");
    }
    //狗特有功能  看门
    public void lookDoor(){
       System.out.println("看门");
    }

public String getKind() {
       return kind;
    }
    public void setKind(String kind) {
       this.kind = kind;
    }
}
/*
 * 自定义类型 家
 * 地址
 * 行为
 * 在家吃饭
 * */

class Home {
    private String address;
    //动物在家吃饭
    //在所有使用父类类型的地方均可以传入其子类对象。
    public void eatAtHome(Animal a){
       //调用Animal的eat方法
       a.eat();
    }
    //狗在在家吃饭
     public void eatAtHome(Dog dog){
      System.out.println("狗在家吃饭");
      //调用狗的eat方法
      dog.eat();
     }
    //猫在家吃饭
     public void eatAtHome(Cat cat){
      System.out.println("猫在家吃饭");
     //调用猫的eat方法
      cat.eat();
     }
    public String getAddress() {
       return address;
    }
    public void setAddress(String address) {
       this.address = address;
    }
}

/**
     * 测试家类
    */
     class Test {
    public static void main(String[] args) {
        //  创建Home对象
        Home home = new  Home();
          Animal a = new Animal();
          home.eatAtHome(a);
        //在所有使用父类类型的地方均可以传入其子类对象。

Dog d = new Dog();
        home.eatAtHome(d);
        Cat c = new Cat();
        home.eatAtHome(c);
    }
}



动物类：



java之继承精选_代码_04



猫类继承动物类：



java之继承精选_Java_05



狗类继承动物类：



java之继承精选_继承_06



自定义类型：家



java之继承精选_概念_07



主方法调用：



java之继承精选_代码_08



结果打印：



java之继承精选_代码_09



4、方法重写



4.1、方法重写概念



    当子类继承父类后，拥有了父类的成员并可以直接调用父类非私有方法。如果子类认为父类提供的方法不够强大，子类可以按照子类自身的逻辑重新定义继承过来的父类方法，这个重新定义一个方法的过程叫做方法重写。(注：在学习完多态和抽象类后我们会对方法重写有更深的理解)



4.2、方法重写格式



    子类中定义与父类一样的方法便将父类的方法重写了。此时，当创建子类对象，调用方法时，会调用子类重写后的方法。如：



    子类中定义与父类一样的方法声明即是方法重写



    子类定义：



package com.Test;


 class Person{
    private String name;

public void eat(){
        System.out.println("吃饭");
    }

}
    //子类定义：
 class Chinese extends Person{
     //@override是用于强制规定当前定义的方法一定为重写的方法
        @Override
        public void eat() {
            System.out.println("按照中国的习惯，用筷子吃饭");
        }
        String name;

public String getName() {
            return name;
        }

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

class Test{
    public static void main(String[] args) {
        Chinese c = new Chinese();
        c.setName("磊哥");
        //父类继承方法直接调用
        String name = c.getName(); 
        //打印结果为磊哥
        System.out.println(name);

//方法重写后调用的为重写后的方法
        //打印结果：按照中国的习惯，使用筷子吃
        c.eat();

}
}



java之继承精选_继承_10



java之继承精选_Java_11



 父类定义：



/**
    自定义类型  人类
     *
    姓名  年龄
     */
    public class Person { 
       String address;
       private String name;
       private int age;

public void eat(){
           System.out.println("吃");    
       }
       public void sleep(){
           System.out.println("睡");
       }
       public String getName() {
           return name;
       }
       public void setName(String name) {
           this.name = name;
       }
       public int getAge() {
           return age;
       }
       public void setAge(int age) {
           this.age= age;
       }
    }
/*
    定义类型  学生类
     *
    姓名  年龄
     *
    继承
    概念1  当定义一个类时，发现现有类与要定义的类类似，并且要定义的类属于现有类的一种时，
    就可以将这个类定义为现有类的子类
     *

*
  子类拥有父类的所有属性与方法，无需重新定义。并且可以直接使用非私有的父类成员。
 *
  父类私用的成员变量  可以使用get/set方法
访问
 *
  父类私有的方法  没有办法直接方法  虽然继承了
但是相当于没有
 *
  子类可以有自己特有的属性和方法
 *
  方法重写
 *
   子类继承父类后，可以直接使用父类的非私有成员，但是如果觉得父类的成员方法不够强大，子类可以按照自身的逻辑
 *
   将继承过来的父类方法，进行重写（方法重写，方法复写，方法覆盖）
 *
  可以使用@Override来验证你的方法是不是重写方法。

*/
 class Student extends Person{
    private String number;
    public void method(){
       System.out.println(address);
       System.out.println(getName());
    }

//重写父类eat方法
    @Override
    public void eat(){
       System.out.println("学生吃学生套餐");
    }
    public String getNumber() {
       return number;
    }
    public void setNumber(String number) {
       this.number = number;
    }
}
/*
 * 测试继承后的Studnet

*/
 class Test {
    private final static String name = "磊哥的java历险记-@51博客";
    public static void main(String[] args) {
       //创建Studnet对象
       Student s = new Student();

s.setName("磊哥的java历险记");
       s.setNumber("16");
       s.eat();
         s.sleep();
       String name = s.getName();
       System.out.println(name);
       System.out.println(s.getNumber());
       System.out.println("==============="+name +"===============");

//子类调用自己特有的方法
       s.method();
       }
}



java之继承精选_概念_12



子类继承父类：



java之继承精选_Java_13



主方法调用：



java之继承精选_继承_14



结果打印：



java之继承精选_Java_15



4.3、Java中方法重写规则



子类重写方法时，在声明前加@Override可检测该方法是否为重写的方法



访问权限相同或子类方法访问权限更大(访问权限顺序public>默认)



class Fu{ 
    void show(){
    }
}
class Zi extends Fu{
    public void show(){//编译运行没问题
    }  

//编译错误
    void method(){
    }      
}



方法名称必须相同



参数列表必须相同 



返回值为基本类型时必须相同



返回值为引用类型时相同或子类小(了解) 



代码演示：



package com.Test;

/*
 * 方法重写的注意事项
 *  子类重写方法时，在声明前加@Override可检测该方法是否为重写的方法
 *  访问权限相同或子类方法访问权限更大(访问权限顺序public>默认)
 *  方法名称必须相同
 *  参数列表必须相同
 *  返回值为基本类型时必须相同
 *  返回值为引用类型时相同或子类小(了解)
 */
 public  class Person {

public void  eat() {
        System.out.println("吃饭");
    }
    public double height(){
        return 3.5;
    }
    public Student get(){
        return null;
    }
}
class Student extends Person {
    //访问权限相同或子类方法访问权限更大(访问权限顺序public>默认)
    @Override
    public void  eat() {
        System.out.println("不能喝酒");
    }
        //返回值为基本类型时必须相同
        public double height(){
            return 1.7;
        }
        //返回值为引用类型时相同或子类小(了解)
        @Override
        public Student get(){
            return null;
        }

}



java之继承精选_Java_16



概念和代码虽多一些，但是我已经尽量用最简单的话语描述了，概念的理解就看兄弟们自己的了，我已经替大家削弱很多了，兄弟们可以动动手敲一敲代码，加深自己的感受~



感谢兄弟们持续关注！



java之继承精选_代码_17

        

        

            

                report
            

        

    







        
Recommend

        



                

    
About Joyk

    
 





Aggregate valuable and interesting links.

Joyk means Joy of geeK