面向对象——继承

已于 2024-07-17 20:41:12 修改
阅读量136 收藏 4
点赞数 6
文章标签： java 前端 开发语言
于 2024-07-16 22:19:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80708315/article/details/140447999
版权

基本概念 

package com.itheima.di_staticdemo.d6;

public class A {
        //公开成员
      public  int i;
      public  void  print1()
      {
          System.out.println("====print1====");
      }
      //私有成员
      private int j;
      private void  print2()
      {
          System.out.println("===printf2===");
      }
}


  //B称为子类，A为父类
public class B extends A {
        //子类能继承父类的非私有的成员
       public  void  print3()
       {
           System.out.println(i);
           print1();


//        私有   System.out.println(j);
//           print2();
       }
}

public class Test1 {
    public static void main(String[] args) {
          B b = new B();//b对象是多张设计图做出来的，可以访问多张设计方法


    }
}

public class People {
        private  String name;

    public String getName() {
        return name;
    }

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

public class Teacher  extends  People {
      private  String skill;

    public String getSkill() {
        return skill;
    }

    public void setSkill(String skill) {
        this.skill = skill;
    }
    public  void  printInfo()
    {
        System.out.println(getName() + "具备的技能" + skill);
    }
}

public class Test {
    public static void main(String[] args) {
        Teacher t =new Teacher();
        t.setName("刘翀羽");
        t.setSkill("java Spring");
        System.out.println(t.getName());
        System.out.println(t.getSkill());
        t.printInfo();
    }
}

 权限修饰符

public class Fu {
                //1,私有，只能在本类中访问
    private  void  privateMethod()
    {
        System.out.println("==private===");
    }
    //2,缺省，本类，同一个包下的类
    void  method()
    {
        System.out.println("==缺省==");
    }
     //3，protected 本类，同一个包下的类，任意包下的子类
       protected  void  protectedMothod()
       {
           System.out.println("==protected====");
       }
       //4,public   本类，同一个包下的类，任意下包下的子类，任意包下的任意类
       public void publicMothod()
       {
           System.out.println("==public===");
       }
            public void  test()
            {
                
            }
}

super

 

this:代表本类对象的引用（this关键字指向调用该方法的对象一般我们是在当前类中使用this关键字所以我们常说this代表本类对象的引用）
super:代表父类存储空间的标识(可以理解为父类对象引用)

关键字访问成员变量   访问构造方法 访问成员方法
this  this.成员变量
访问本类成员变量		this(...)
访问本类构造方法		this.成员方法(...)
访问本类成员方法
super  super.成员变量
访问父类成员变量		super(...)
访问父类构造方法		super,成员方法(...)
访问父类成员方法

 

 

单继承与Object

注上面这张照片中a的方法就是object

 

方法重写 

public class A {
        public  void  print1()
        {
            System.out.println("111");
        }
        public void print2(int a,int b)
        {
            System.out.println("111111");
        }

}
public class B  extends A{
    //方法重写
    public  void  print1()
    {
        System.out.println("666");
    }
    //方法重写
    public  void  print2(int a,int b)
    {
        System.out.println("666666");
    }
}


public class Test {
    public static void main(String[] args) {
        //方法重写就近原则b对象就先执行打印6
            B b =new B();
            b.print1();
            b.print2(2,3);
    }
}

       核心：声明不变，重新实现 

public class Student {
          private  String name;
          private  int age;

    public Student() {

    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }
    //toString快捷方式

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Test {
    public static void main(String[] args) {
        //方法重写就近原则b对象就先执行打印6
            B b =new B();
            b.print1();
            b.print2(2,3);
        System.out.println("---------------------");
            Student s =new Student("波妞",19);
        System.out.println(s.toString());
        System.out.println(s);
    }
}

 

子类中访问其他成员的特点

在子类中访问其他成员（成员变量，成员方法），是依照就近原则的

public class F {
       String name ="父类名字";
       public  void  print1()
       {
           System.out.println("==父类的print1方法执行==");

       }
}

问题：关于下面的 this使用原理

public class Z extends F{
        String name="子类名称";

       public  void  showName()
       {
           String name="局部名称";
           System.out.println(name);//局部名称
           System.out.println(this.name);//子类成员变量（访问子类成员变量
           System.out.println(super.name);//父类成员变量
       }
       @Override

       public void print1()
       {
           System.out.println("====子类的print1方法执行了=====");
       }
       public void showMethod()
       {
           print1();//就近就打印子类的print1方法执行了
           super.print1();//父类中的print
       }
}

public class Test {
    public static void main(String[] args) {
        Z z =new  Z();
        z.showName();
        z.showMethod();
    }

}

 子类构造器的特点

子类的全部构造器，都会先调用父类的构造器，再执行自己。

class  F{
//            public F()
//            {
//                System.out.println("===父类的无参数构造器执行了==");
//            }
//  }
      public  F(String name ,int age)
      {

      }
  }
  class  Z extends F{
                public  Z()
                {
                    super("liucyu",18);//因为没有了无参构造器所以要使用有参去使用
                    //super();//默认存在，调用父类
                    System.out.println("===子类的无参数构造器执行了==");
                }
      public  Z(String name)
      {
          super("12",11);
          System.out.println("===子类的有参数构造器执行了==");
      }

  }

public class Test {
    public static void main(String[] args) {
                Z z =new Z();
                Z z2 = new Z("刘翀羽");

    }
}

先调用父类再是自己 用super可调用父类构造器

public class Test2 {
    public static void main(String[] args) {
             Teacher t =new Teacher("刘翀羽",19,"java");
        System.out.println(t.getName());
        System.out.println(t.getAge());
        System.out.println(t.getSkill());
    }
}
class  Teacher extends People{
                private String skill;

    public Teacher(String name, int age, String skill) {
        super(name, age);
        this.skill = skill;
    }

    public String getSkill() {
        return skill;
    }

    public void setSkill(String skill) {
        this.skill = skill;
    }
}
class People{
    private  String name;
    private int age;

    public People(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public People() {
    }

    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;
    }
}

需求，若用户输入时没有输入学校，则学小默认为黑马程序员

public class Test2 {
    public static void main(String[] args) {
         Studnet s1= new Studnet("李四",26,"家里蹲大学");
         //需求，若用户输入时没有输入学校，则学小默认为黑马程序员
        Studnet s2 =new Studnet("李华",15);
    }
}
  class  Studnet{
    private  String name;
    private int age;
    private  String schoolName;
            public  Studnet(String name,int age)
            {//关键；若用户输入时没有输入学校，则学小默认为黑马程序员
                this.name=name;
                this.age=age;
                this.schoolName="黑马程序员";
            }
      public Studnet() {

      }

      public Studnet(String name, int age, String schoolName) {
          this.name = name;
          this.age = age;
          this.schoolName = schoolName;
      }

 改进版

 private  String schoolName;
            public  Studnet(String name,int age)
            {
                this(name,age,"黑马程序员");
            }

 注：this（）与super（）不能同时出现在构造器中

 public Studnet(String name, int age, String schoolName) {
        this(name,age,schoolName);
      }
//直接单独使用会报错，只有当是兄弟构造器才可以使用this（）

2301_80708315
关注
Python面向对象——继承和多继承
qq_37235798的博客
07-31 2596
单继承： 面向对象的主要好处就是代码的重用，实现这一特点通过继承，继承创建的新类成为子类，被继承的类称为父类。 如果在子类中需要父类的构造方法就需要显示的调用父类的构造方法，在调用基类的方法时，需要加上基类的类名前缀，且需要带上 self 参数变量。 下面我们开始来讲解继承和多继承 首先我们创建两个类， 父类：Father类  子类：Child 父类中属性为money，和一个方法pla...
Java面向对象——继承（超详细讲解）
Best_Basic的博客
08-11 5641
Java继承：是面向对象最显著的一个特性。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。 JAVA不支持多继承，单继承使JAVA的继承关系很简单，一个类只能有一个父类，易于管理程序，同时一个类可以实现多个接口，从而克服单继承的缺点。......
Java基础面向对象——继承
weixin_55958095的博客
09-26 326
Java基础面向对象——继承
Java面向对象——继承(1)
m0_68828514的博客
11-28 496
本篇文章来给大家讲解java面向对象三大特性中的继承。本次的内容相比上篇的封装内容要多很多，同时难度也有所增加，我会用最通俗，最直观的案例带大家学习。继承这一章节我会分三次进行讲解，初识继承、深入继承特性以及继承JVM内存分布。如果能将继承深入的理解，那么你对OOP设计思想也会得到质的飞跃，同时也为今后的学习打下坚实的基础！接下来带大家初识面向对象的继承。
JAVA面向对象——继承
Allen 专栏-移动互联网
10-30 4588
1.继承的好处：
C#——面向对象——继承——继承
DC的博客
06-13 308
好处：提高开发效率 如果B类的基类是A类，那么B类拥有A类所有成员 格式： class B:A{} 所有类的共同基类是Object类，它是唯一的非派生类，其它类是派生类或基类都是相对的 C#中的继承，是单继承，但可以多重继承（C++当中可以多继承）
C#——面向对象——继承——接口
DC的博客
06-14 276
接口的强大之处在哪儿里呢？ 一个类只能继承一个类，一个类可以实现多个接口。如果一个类即继承了基类，又实现了接口，那么要注意格式，基类一定要放在第一位
面向对象——继承实验报告.doc
12-11
Java实验报告
c#面向对象——继承
03-12
c#面向对象——继承
面向对象——操作符
01-20
在编程领域，面向对象是一种重要的编程范式，它基于对象的概念，通过封装、继承和多态等特性，使代码更加模块化和易于管理。在JavaScript中，面向对象的实现主要依赖于构造函数、原型和实例。本文将详细介绍几个在...
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 881
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
JDK1.0主要特性
FoolRabbit的专栏
10-06 285
JDK1.0主要特性。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 625
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
Spring依赖注入和注解驱动详解和案例示范
J老熊
10-01 1000
在 Spring 框架中，依赖注入（Dependency Injection, DI）和注解驱动（Annotation-Driven）是其核心机制，它们为 Spring 应用提供了灵活性和可扩展性。依赖注入简化了对象间的依赖管理，而注解驱动则通过简洁的注解配置取代了繁琐的 XML 配置。本文将详细分析这两个机制，并通过示例加深理解。
JavaScript ArrayBuffer的读写与类型转换
白瑕 的博客
10-01 489
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
Springboot人才求职招聘系统源码（前台+后台）
最新发布
10-06 456
项目技术：springboot运行环境：jdk1.8+idea/eclipse+maven3+mysql5.6。
PHP面向对象：继承与this关键字详解
本文将深入探讨PHP面向对象编程中的一个重要概念——`this`关键字，以及相关的继承、访问控制和重写等关键知识点。在PHP5中，面向对象编程得到了强化，使得开发者可以更有效地构建和复用代码。 首先，`this`关键字...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值