首页 > 其他分享 >继承

继承

时间:2023-04-14 13:33:57浏览次数:41  
标签:String 继承 子类 System println 父类 public

1. 继承接上

2. 继承的好处

1) 代码的复用性提高了

2) 代码的扩展性和维护性提高了

3. 继承的深入讨论及细节288

1) 子类继承了所有的属性和方法,非私有的属性和方法可以在子类直接访问, 但是私有属性和方法不能在子类直接访 问,要通过父类提供公共的方法去访问 288

2) 子类必须调用父类的构造器, 完成父类的初始化 289

3) 当创建子类对象时,不管使用子类的哪个构造器,默认情况下总会去调用父类的无参构造器,如果父类没有提供无 参构造器,则必须在子类的构造器中用 super 去指定使用父类的哪 个构造器完成对父类的初始化工作,否则,编译 不会通过(怎么理解。) [举例说明] 289

4) 如果希望指定去调用父类的某个构造器,则显式的调用一下 : super(参数列表) 290

5) super 在使用时,必须放在构造器第一行(super 只能在构造器中使用) 290

6) super() 和 this() 都只能放在构造器第一行,因此这两个方法不能共存在一个构造器 290

7) java 所有类都是 Object 类的子类, Object 是所有类的基类. 291

8) 父类构造器的调用不限于直接父类!将一直往上追溯直到 Object 类(顶级父类) 291

9) 子类最多只能继承一个父类(指直接继承),即 java 中是单继承机制。 思考:如何让 A 类继承 B 类和 C 类? 【A 继承 B, B 继承 C】 292

10) 不能滥用继承,子类和父类之间必须满足 is-a 的逻辑关系 292

3.1 细节举例,由于内容众多参考视频讲解

代码在com.stulzl.extend_.包中

测试ExtendsDetail
package com.stulzl.extend_;

public class ExtendsDetail {   //288
    public static void main(String[] args) {

//        Sub sub = new Sub();  //288
//        //sub.sayOk();
//
//        System.out.println("==========");  //289
//        Sub sub2 = new Sub("jack");

        System.out.println("==========");  //290
        Sub sub3 = new Sub("jack",13);
    }
}
父类Base
package com.stulzl.extend_;

public class Base {  //父类
    //4个属性
    public int n1 = 100;
    protected int n2 = 200;
    int n3 = 300;
    private int n4 = 400;

    //无参构造器
    public Base() {
        System.out.println("父类Base()构造器被调用....");
    }
    //有参构造器1
    public Base(String name, int age) {
        //默认super()
        System.out.println("父类Base(String name, int age)构造器被调用....");
    }
    //有参构造器2
    public Base(String name) {
        System.out.println("父类Base(String name)构造器被调用....");
    }

    //父类提供一个公共的getN4方法,返回了n4
    public int getN4() {
        return n4;
    }
    //4 个方法
    public void test100() {
        System.out.println("test100");
    }
    protected void test200() {
        System.out.println("test200");
    }
    void test300() {
        System.out.println("test300");
    }
    private void test400() {
        System.out.println("test400");
    }

    //提供一个公共callTest40方法调用test400
    public void callTest400() {
        test400();
    }
}
子类Sub
package com.stulzl.extend_;

//输入Ctrl+H可以看到类的继承关系
public class Sub extends Base//子类
{
    //如果希望指定去调用父类的某个构造器,则显式的调用一下 : super(参数列表)  290
    public Sub(String name,int age){
        //1.我们先调用父类无参构造器
        //super();  //super 在使用时,必须放在构造器第一行

        //2. 我们调用父类的有参构造器2 Base(String name)
        super("lzl");

        System.out.println("子类Sub(String name,int age)构造器被调用……");
    }

    public Sub() {//无参构造器
        //子类必须调用父类的构造器,完成父类的初始化

        //super();//此句被隐藏,作用是默认调用父类无参构造器

        //如果父类没有提供无 参构造器,则必须在子类的构造器中用 super 去指定使用父类的哪
        // 个构造器完成对父类的初始化工作,否则,编译 不会通过
        super("smith",10);//此句特别指定父类构造器
        System.out.println("子类sub()构造器被调用……");
    }

    //当创建子类对象时,不管使用子类的哪个构造器,默认情况下总会去调用父类的无参构造器  289
    public Sub(String name){
        super("tom",30);//此句特别指定父类构造器
        System.out.println("子类Sub(String name)构造器被调用……");
    }

    //   子类继承了所有的属性和方法,非私有的属性和方法可以在子类直接访问,
    //   但是私有属性和方法不能在子类直接访 问,要通过父类提供公共的方法去访问
    public void sayOk()//子类方法
    {
        //非私有的属性和方法可以在子类直接访问,即n4不能直接访问
        //但是私有属性和方法不能在子类直接访
        System.out.println(n1+" "+n2+" "+n3+" ");
        test100();
        test200();
        test300();
        //test400();不能直接访问
        //要通过父类提供公共的方法去访问
        System.out.println("n4="+getN4());
        callTest400();
    }
}

4. 继承的本质分析 293

4.1 案例 293

继承_父类

继承_继承_02

访问规则

//1. 先看子类是否有该属性并且可以访问,则返回信息

//2. 如果子类没有,则看父类(如果父类有该属性,且可以访问,则返回信息)

//3. 如果父类没有,就重复按照2.的规则继续向上级父类,直到Object

代码在com.stulzl.extendstheory_.包中

ExtendsTheory

import sun.security.jgss.GSSUtil;

//继承的本质分析
public class ExtendsTheory {
    public static void main(String[] args) {
        Son son = new Son();

        //输出谁的名字呢,要按照查找关系来返回信息
        //1. 先看子类是否有该属性并且可以访问,则返回信息
        //2. 如果子类没有,则看父类(如果父类有该属性,且可以访问,则返回信息(如果有但不可以访问,就报错))
        //3. 如果父类没有,就重复按照2.的规则继续向上级父类,直到Object
        System.out.println(son.name);//大头儿子
        System.out.println(son.age);//39
        //System.out.println(son.getAge());//40
        System.out.println(son.hobby);//旅游
    }
}
class Grandpa{//爷类
    String name="大头爷爷";
    String hobby="旅游";
}
class Father extends Grandpa{//父类
    String name="大头爸爸";
    int age = 39;

//    private int age = 40;
//    public int getAge(){
//        return age;
//    }
}
class Son extends Father{//子类
    String name="大头儿子";
}

5.继承练习

5.1 判断输出 294

代码在com.stulzl.extends_exercise.包中

ExtendsExercise01

package com.stulzl.extends_exercise;

public class ExtendsExercise01 {
    public static void main(String[] args) {
        B b = new B();//a , b name , b
    }
}
class A{
    A() {
        System.out.println("a");
    }
    A(String name){
        System.out.println("a name");
    }
}

class B extends A{
    B() {//无参构造器
    //因为有了this语句,所以此语句就不会有默认的super了
        this("abc");//执行调用B(String name)构造器之前,会默认的调用A类的无参构造器,然后在执行B有参,后A无参        
        System.out.println("b");
    }
    B(String name){//有参的构造器
        System.out.println("b name");
    }
}

继承_子类_03

5.2 判断输出 295

代码在com.stulzl.extends_exercise.包中

ExtendsExercise01

//判断输出2   295
public class ExtendsExercise01 {
    public static void main(String[] args) {
        C c = new C();
    }
}

class A {//A 类
    public A() {
        System.out.println("我是 A 类");
    }
}

class B extends A { //B 类,继承 A 类 //main 方法中: C c =new C(); 输出么内容? 3min
    public B() {
        System.out.println("我是 B 类的无参构造");
    }
    public B(String name) {
        System.out.println(name + "我是 B 类的有参构造");
    }
}

class C extends B { //C 类,继承 B 类
    public C() {
        this("hello");
        System.out.println("我是 c 类的无参构造");
    }
    public C(String name) {
        super("hahah");
        System.out.println("我是 c 类的有参构造");
    }
}

继承_继承_04

5.3 编程题 296

编写 Computer 类,包含 CPU、内存、硬盘等属性,getDetails 方法用于返回 Computer 的详细信息

编写 PC 子类,继承 Computer 类,添加特有属性【品牌 brand】

编写 NotePad 子类,继承 Computer 类,添加特有属性【color】

编写 Test 类,在 main 方法中创建 PC 和 NotePad 对象,分别给对象中特有的属性赋值,以及从 Computer 类继承的 属性赋值,并使用方法并打印输出信息

代码在com.stulzl.extends_exercise3.包中

测试ExtendsExercise03

package com.stulzl.extends_exercise3;

//编写 Computer 类,包含 CPU、内存、硬盘等属性,getDetails 方法用于返回 Computer 的详细信息
//编写 PC 子类,继承 Computer 类,添加特有属性【品牌 brand】
//编写 NotePad 子类,继承 Computer 类,添加特有属性【color】
//编写 ExtendsExercise03 类,在 main 方法中创建 PC 和 NotePad 对象,分别给对象中特有的属性赋值,
// 以及从 Computer 类继承的 属性赋值,并使用方法并打印输出信息
public class ExtendsExercise03 {
    public static void main(String[] args) {
        PC pc = new PC("intel", 16, 512, "IBM");
        pc.printInfo();
        Notepad notepad = new Notepad("黑色");
        notepad.printInfo2();
    }
}

父类Computer

package com.stulzl.extends_exercise3;

//编写 Computer 类,包含 CPU、内存、硬盘等属性,getDetails 方法用于返回 Computer 的详细信息
public class Computer { //父类
    private String cpu;
    private int memory;
    private int disk;

    //无参构造器
    public Computer() {

    }
    //构造器
    public Computer(String cpu, int memory, int disk) {
        this.cpu = cpu;
        this.memory = memory;
        this.disk = disk;
    }
    //返回Computer的信息
    public String getDetails(){
        return "cpu="+cpu+"  memory="+memory+"  disk="+disk;
    }

    public String getCpu() {
        return cpu;
    }
    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public int getMemory() {
        return memory;
    }
    public void setMemory(int memory) {
        this.memory = memory;
    }

    public int getDisk() {
        return disk;
    }
    public void setDisk(int disk) {
        this.disk = disk;
    }
}

子类PC

package com.stulzl.extends_exercise3;

//编写 PC 子类,继承 Computer 类,添加特有属性【品牌 brand】
public class PC extends Computer {
    private String brand;

    //这里也体现: 继承设计的基本思想,父类的构造器完成父类属性初始化
    //子类的构造器完成子类属性初始化
    //构造器
    public PC(String cpu, int memory, int disk, String brand) {
        super(cpu, memory, disk);
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }

    //输出信息
    public void printInfo(){
        System.out.println("PC的信息如下");
        //调用父类的 getDetails 方法,得到相关属性信息
        System.out.println(getDetails()+" brand="+brand);
    }
}

子类Notepad

package com.stulzl.extends_exercise3;

public class Notepad extends Computer {
    private String color;

    //构造器
    public Notepad(String color) {
        super();
        this.color = color;
    }

    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    //输出信息
    public void printInfo2(){
        System.out.println("color="+color);
    }
}


标签:String,继承,子类,System,println,父类,public
From: https://blog.51cto.com/u_15784725/6189932

相关文章

  • 4月13日继承学习
    之前在c语言写学生管理系统时操作对象只是学生,对学生进行增删查改,若是想要定义老师的结构题又有很大的工作量,但是其中成员变量又有很多重复的,C++的继承可以很好的解决这种问题,继承分为私有保护和公有继承,一般私有继承和保护继承很少用到,所以大多是公有继承派生类分别继承基类的共......
  • python面向对象(继承)
    一继承1、什么是继承1)继承是一种创建新类的方式,新建的类可称为子类或派生类,父类又可称为基类或超类子类会遗传父类的属性2)需要注意的是:python支持多继承在python中,新建的类可以继承一个或多个父类classParent1:passclassParent2:passclassSub1(Paren......
  • 类的继承5
    #include<iostream>#definepi3.14usingnamespacestd;classShape{public:virtualfloatgetArea(){return0;}virtual~Shape(){}};classRectangle:publicShape{private:intlenth,width;public:Rectangle(intlen,intwid):lenth(len),width(w......
  • 类的继承6
    #include<iostream>usingnamespacestd;classMammal{ public: Mammal(){ cout<<"Mammal构造"<<endl; } ~Mammal(){ cout<<"析构Mammal"<<endl; }};classDog:publicMammal{ public: Dog(){ cout<<&quo......
  • 类的继承4
    #include<iostream>usingnamespacestd;classBase0{ public: intvar0; voidfun0(){ cout<<"MemberofBase0"<<endl; }};classBase1:virtualpublicBase0{ public: intvar1;};classBase2:virtualpublicBase0{ public: intvar2;......
  • 跟着查老四学Python Day 9:继承和多态
    继承例行寒暄之后,课程正式开始查老四:继承是面向对象编程中的一个重要概念。它允许我们创建一个新类,继承一个现有类的属性和方法,从而实现代码的重用。新类被称为子类,现有类被称为父类。在Python中,通过在子类名后的括号中写入父类名来实现继承。下面是一个简单的示例#父类classAni......
  • 关于a标签未能继承父盒子color颜色
    <div><ahref="">www</a></div>div{color:red;}从结构上来说肯定期望a标签能够继承div的color属性将文字的颜色设置为红色但实际的网页表现为看上去并没有继承color打开开发者工具查看后发现这里a标签继承的color被划掉了,因为继承的权重太低了为0......
  • 类的继承3
    #include<iostream>usingnamespacestd;classBase1{ public: intvar; voidfun() { cout<<"MembberofBase1"<<endl; } };classBase2{ public: intvar; voidfun(){ cout<<"MemberofBase2"<<endl; }};......
  • 类的继承2
    #include<iostream>usingnamespacestd;classBase1{ public: Base1(inti){ cout<<"ConstructingBase1"<<i<<endl; } Base1(){ cout<<"ConstructingBase1"<<endl; }};classBase2{ public: Base2(intj......
  • 类的继承1
    #include<iostream>usingnamespacestd;classBase1{ public: Base1(inti){ cout<<"ConstructingBase1"<<i<<endl; }};classBase2{ public: Base2(intj){ cout<<"ConstructingBase2"<<j<<endl; ......