Java的封装与继承

最新推荐文章于 2024-07-30 20:50:32 发布
最新推荐文章于 2024-07-30 20:50:32 发布
阅读量175 收藏
点赞数
分类专栏： Java韩顺平 Java韩顺平知识点补充 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kingJamesbond/article/details/120174591
版权

封装继承

访问修饰符

  • public，对外公开
  • protected，对子类和同一个包中的类公开
  • 默认级别
  • private，只有本身可以访问

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7yNwxPSX-1631068658025)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/4b5d501c-76ef-4870-a3c6-226776ca2588/Untitled.png)]

访问修饰符的细节

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tzMFlozE-1631068658029)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/24f97179-0d6e-4bdb-82d3-653ea99c9cdc/Untitled.png)]

  • 修饰符可以用来修饰类中的属性，成员方法以及类
  • 只有默认的和public才可以修饰类，并且遵循上述访问权限的特点
  • 成员方法的访问规则和属性完全一样

封装

封装就是把抽象出来的数据[属性]和对数据操作[方法]封装在一起，数据被保护在内部，程序的其他部分只有通过被授权的操作[方法]才能对数据进行操作（对电视机的操作就是典型封装）

可以隐藏实现细节：方法（连接数据库）< - -调用（传入参数）

可以对数据进行验证，保证安全合理

封装实现的步骤

  • 将属性私有化（不能直接修改属性）
  • 提供一个公告的set方法，用于对数学判断并赋值（可以假如数据验证的业务逻辑）
public void set(类型 参数名）
{
		属性=参数名
}
  • 提供一个公共的get方法，用于获取属性的值
public 数据类型 get()
{
		return xx;
}

封装的简单例子

目的：不能随便查看人的年龄，工资等隐私，年龄要合理设置，name的长度在2~6之间

package com.hh.encap;

public class Encapsulation01 {

    public static void main(String[] args) {
        Person person=new Person();
        person.setName("jack8888");
        person.setAge(38);
        person.setSalary(30000);
        System.out.println(person.info());

    }
}
class Person{
    public String name;
    private int age;
    private double salary;
    //使用快捷键生成，更快

    public String getName() {
        return name;
    }

    public void setName(String name) {
        if (name.length() >= 2 && name.length() <= 6) {
            this.name = name;
        }
        else {
            System.out.println("你的名字长度不符合要求，需要在2~6,默认姓名为第一书记");
            this.name="第一书记";
        }
    }
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age >= 1 && age <= 120) {
            this.age = age;
        }
        else{
            System.out.println("你设置的年龄不对，需要在1-120以内，给一个默认年龄为18");
            this.age=18;//给默认年龄
        }
    }
    public double getSalary() {
        //可以在这里增加判断或者限定
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
    //写一个方法返回
    public String info()
    {
        return "信息为name= "+name+" age= "+age+" 薪水 "+salary;
    }
}

封装与构造器的配合使用

package com.hh.encap;

public class Encapsulation01 {

    public static void main(String[] args) {
        Person person=new Person();
        person.setName("jack8888");
        person.setAge(38);
        person.setSalary(30000);
        System.out.println(person.info());
        Person smith=new Person("smith",300,1200);
        System.out.println("=============\n"+smith.info());
    }
}
class Person{
    public String name;
    private int age;
    private double salary;
    
     public  Person()
      {

     }
     //三个属性的构造器
    public Person(String name, int age, double salary) {

        //可以将set方法下载构造器，仍然可以验证
        setName(name);
        setAge(age);
        setSalary(salary);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        if (name.length() >= 2 && name.length() <= 6) {
            this.name = name;
        }
        else {
            System.out.println("你的名字长度不符合要求，需要在2~6,默认姓名为第一书记");
            this.name="第一书记";
        }
    }
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age >= 1 && age <= 120) {
            this.age = age;
        }
        else{
            System.out.println("你设置的年龄不对，需要在1-120以内，给一个默认年龄为18");
            this.age=18;//给默认年龄
        }
    }
    public double getSalary() {
        //可以在这里增加判断或者限定
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }
    //写一个方法返回
    public String info()
    {
        return "信息为name= "+name+" age= "+age+" 薪水 "+salary;
    }
}

简单练习

在AccountTest类中进行测试

package com.hh.encap;

public class AccounTest {
    public static void main(String[] args) {
            Account cu=new Account("puy",200.1,"457897");
            System.out.println(cu.info());
    }
}

package com.hh.encap;

public class Account {
    private String name;
    private double account;
    private String cord;

    public Account(String name, double account, String cord) {
        this.setName(name);
        this.setAccount(account);
        this.setCord(cord);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        if (name.length() ==2|| name.length() == 4||name.length()==3) {
            this.name = name;
        } else {
                System.out.println("名字的长度需要在2~4之间,默认值为冯书记");
                this.name="冯书记";
        }
    }
    public double getAccount() {
        return account;
    }

    public void setAccount(double account) {
        if(account>20)
        {
            this.account = account;
        }
        else{
            System.out.println("余额不满20,系统设置默认值为20");
            this.account=20;
        }
    }

    public String getCord() {
        return cord;
    }

    public void setCord(String cord) {
        if(cord.length()==6)
        {
            this.cord = cord;
        }
        else{
            System.out.println("你输入的密码长度不符合6位,系统默认密码位123456");
            this.cord="123456";
        }
    }
    public String info()
    {
        return "您的信息是:"+name+"余额: "+account+"密码:"+cord;
    }
}

继承

为什么需要继承？

package com.extend_;

public class Extend01 {
    public static void main(String[] args) {
        Pupil p=new Pupil();
        p.name="小明";
        p.age=10;
        p.show();
        p.setScore(90);
        p.info();
        System.out.println("=====================");
        Graduate g=new Graduate();
        g.name="cmg";
        g.age=21;
        g.show();
        g.setScore(100);
        g.info();
    }
}

package com.extend_;

public class Pupil {
    public String name;
    public int age;
    private double score;

    public void setScore(double score) {
        this.score = score;
    }
    public void show()
    {
        System.out.println("小学生"+name+"正在考试小学数学");
    }
    public void info()
    {
        System.out.println("信息如下: 姓名："+name+"年龄:"+age+"成绩"+score);
    }
}

package com.extend_;

public class Graduate {
    public String name;
    public int age;
    private double score;

    public void setScore(double score) {
        this.score = score;
    }
    public void show()
    {
        System.out.println("大学生"+name+"正在考试大学数学");
    }
    public void info()
    {
        System.out.println("学生名："+name+"年龄:"+age+"成绩"+score);
    }
    //两个类很多是相同
}

从这三个可以看出，代码的冗余度很高，大部分的属性和方法是意愿的，因此需要代码复用

继承的基本语法

class 子类 extends 父类
{

}
  • 子类就会自动拥有父类定义的属性和方法
  • 父类又叫超类和基类
  • 子类又叫派生类

继承的简单使用

创建一个父类将Graduate和pupil共有的属性和方法放在一起

package com.extend_.improve_;

//父类，pupil和graduate
public class Student {
    //共有属性
    public String name;
    public int age;
    private double score;
    public void setScore(double score) {
        this.score = score;
    }
    //公有方法
    public void info()
    {
        System.out.println("信息如下: 姓名："+name+"年龄:"+age+"成绩"+score);
    }
}

子类继承

package com.extend_.improve_;

public class Graduate extends Student{
    public void show()
    {
        System.out.println("大学生"+name+"正在考试大学数学");
    }
}

package com.extend_.improve_;
//pupil继承student类
public class Pupil extends Student{
    public void show()
    {
        System.out.println("小学生"+name+"正在考试小学数学");
    }
}

细节

  • 代码复用性提高
  • 拓展性和维护性提高了
  • 子类继承了所有的属性和方法，但是私有属性和方法不能在子类直接访问，要通过父类提供的公共的方法去访问
  • 子类必须调用父类的构造器，完成父类的初始化
  • 如果父类没有提供无参构造器，则必须在子类的构造器中使用super去指定使用父类的哪个构造器完成对父类的初始化工作
  • 如果希望指定去调用父类的某个构造器，则显式的调用一下：super（参数列表）
  • super在使用时，需要放在构造器第一行
  • super()和this()都只能放在构造器第一行，因此两个方法不能共存在同一个构造器
  • Java所有类是Object类的子类
  • 父类构造器的调用不限于直接父类。将一直往上追溯到object类
  • 子类最多只能继承一个父类（直接继承），单继承机制
  • 不能滥用继承，子类和父类之间必须满足is-a的逻辑关系

继承的本质

当子类对象创建好后，建立查找关系

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F3nC3cI4-1631068658032)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/3eaa4575-1ba6-4cc3-874c-c5cee17d1d51/Untitled.png)]

package com.extend_;

public class ExtendsTheory {
    public static void main(String[] args) {
        Son son=new Son();
        System.out.println(son.name);
        System.out.println(son.age);
    }
}
class Grandpa{
    String name="大头爷爷";
    String hobby="旅游";
    
}
class Father extends Grandpa{
    String name="大头爸爸";
    int age=39;
}
class Son extends Father{
    String name="大头儿子";
}

package com.extend_;

public class ExtendsTheory {
    public static void main(String[] args) {

        B b=new B();//调用B类的无参构造器
    }
}

class A{
    A()
    {
        System.out.println("a");
    }
    A(String name)
    {
        System.out.println("a name");
    }
}
class B extends A{
    B()
    {
        this("abc");
        System.out.println("b");
    }
    B(String name)
    {
        System.out.println("b name");
    }
}

输出结果

a
b name
b

  • 答案解析

    main方法里创建了b,我们看到类B是继承类A，因此创造了无参构造器后，需要跳转到父类，由于是无参输出a，然后A(String name)跳过，执行到this(“abc”)，执行B(String name)输出b name，然后this("abc”)结束执行，执行输出b的语句。

package com.newkk;

public class Exercise2 {
    public static void main(String[] args) {
        C c=new C();
    }
}
class A{
    public A()
    {
        System.out.println("我是A类");
    }
}
class B extends A{
    public B()
    {
        System.out.println("我是B类的无参构造");

    }
    public B(String name)
    {
        System.out.println(name+"我是B类的有参构造");
    }
}
class C extends B
{
    public C()
    {
        this("hello");//调用本类的有参构造
        System.out.println("我是C类的无参构造");
    }
    public C(String name)
    {
        super("hahah");
        System.out.println("我是C类的有参构造");
    }

}

我是A类
hahah我是B类的有参构造
我是C类的有参构造
我是C类的无参构造

关于电脑的一个简单小例子

package com.Extendexercise3;

public class Test {
    public static void main(String[] args) {

       PC pc=new PC("intel",16,500,"IBM");
       pc.info();
       NotePad pad=new NotePad("Intel",16,500,"red");
       pad.info2();

    }
}

package com.Extendexercise3;

public class Computer {
    private String CPU;
    private double memory;
    private int disk;

    public Computer(String CPU, double memory, int disk) {
        this.CPU = CPU;
        this.memory = memory;
        this.disk = disk;
    }

    public String getCPU() {
        return CPU;
    }

    public void setCPU(String CPU) {
        this.CPU = CPU;
    }

    public double getMemory() {
        return memory;
    }

    public void setMemory(double memory) {
        this.memory = memory;
    }

    public int getDisk() {
        return disk;
    }

    public void setDisk(int disk) {
        this.disk = disk;
    }
    public String getDetail()
    {
        return "电脑的信息为:"+"CPU: "+CPU+"内存容量: "+memory+"硬盘:"+disk;
    }
}

package com.Extendexercise3;

public class PC extends Computer{
    private String brand;
//IDEA根据继承的原则，自动把构造器的调用写好
    public PC(String CPU, double 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 info()
    {
        System.out.println(getDetail()+"品牌是"+brand);
    }
}

package com.Extendexercise3;

public class NotePad extends Computer{
    private String color;

    public NotePad(String CPU, double memory, int disk, String color) {
        super(CPU, memory, disk);
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

   public void info2()
    {
        System.out.println(getDetail()+"颜色"+color);
    }
}

super关键字

  • super代表父类的引用，用于访问父类的属性、方法、构造器
  • super能访问父类的属性和方法，但不能是private
super().方法名
super().属性
super(参数列表）用于访问构造器

super的使用细节

  • 调用父类的构造器好处：分工明确，父类属性由父类初始化
  • 当子类有和父类中的成员(属性和方法）重名时，为了访问父类的成员，必须通过super
  • 访问n1和this.n1
  • 多个父类有同名的成员，使用super访问遵循就近原则

在这里插入图片描述

方法的重写

子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，那么我们就说子类的这个方法覆盖了父类的方法

子类方法不能缩小类方法的访问权限

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6KI0ae3k-1631068658038)(https://s3-us-west-2.amazonaws.com/secure.notion-static.com/47cc9a74-c5cf-4096-9c40-b896b19f9fdf/Untitled.png)]

重写的案例

package com.person;

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

    public Person(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;
    }

    public String say()
    {
        return "我是:"+name+"年龄:"+age;
    }
}

package com.person;

public class Student extends Person{
    private int id;
    private double score;
    public Student(String name, int age) {
        super(name, age);
    }

    public Student(String name, int age, int id,double score) {
        super(name, age);
        this.id = id;
        this.score = score;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public double getScore() {
        return score;
    }

    public void setScore(double score) {
        this.score = score;
    }

    public String say()//super的好处
    {
        return super.say()+"id:"+id+"score"+score;//调用父类的C方法
    }
}

package com.person;

public class test {
    public static void main(String[] args) {
            Person man=new Person("王东",50);

        System.out.println(man.say());

        Student smith=new Student("smith",90,855,98.1);
        System.out.println(smith.say());
    }
}
Alfred king
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Java】封装、继承与多态
m0_50987960的博客
10-29 1968
封装、继承、多态与四种访问修饰符
java封装继承多态实验总结_java封装继承多态理解3000字论文
weixin_36302331的博客
03-09 1204
一、怎么理解JAVA中封装、继承、多态他是一个“司机”，他的平时行为还有“开车”，我们再次划分出了“哺乳动物”这个类，一个类只能继承另一个类(或抽象类)但可以实现多个接口。打个比方封装，“鱼”等等)，接着，最后有“马”。 多态，正如上面朋友所说一重写，二重载。用汉字来打个比方，很显然，比如“开”这个字，在不同的时候各有的意思，比如“开门”、继承、多态 继承，先说说我对类的理解，类起到的作用有：分类...
java封装/继承简单实例
尤词的博客
07-13 840
简单的实例帮助读者理解什么是封装，什么是继承
Java封装和继承
Dumpling_skin的博客
04-12 3214
1、封装 封装：隐藏对象的属性和实现细节，仅对外公开接口（方法/函数），控制在程序中属性的读和修改的访问级别 Java中的封装： 1）广义上：一切公共的代码的抽取都可以叫做封装。一般体现在公共方法的封装。工具类。 2）狭义上：隐藏对象的属性和实现细节。①将属性私有化，使用private关键字修饰。②为使用private关键字修饰的属性添加getter和setter方法。通过get和set方法来操作属性。③在setter方法中，添加数据的逻辑校验。 public class Student {
Java 封装 继承 多态（深入理解）
2302_79806056的博客
03-08 3762
详细解析了面向对象编程（java）的三大特性：封装继承和多态（超详细）收藏精品，帮助加深理解
JAVA封装，继承，多态详解
qq_48984694的博客
07-26 3301
Java封装，继承，多态详解，带代码示例。
java封装 继承 多态_Java 封装、继承、多态
weixin_39850331的博客
02-22 2670
Java 封装、继承、多态1.封装：封装的理解：将类的某些信息隐藏在类的内部，不允许外部程序直接访问，并通过该类提供的方法来实现对隐藏信息的操作和访问。(简单的说就是隐藏对象的信息，留出访问的接口)。特点：1.只能通过规定的方法访问数据；2.隐藏类的实例细节，方便修改和实现。实现封装的方式:使用访问控制符：java提供了三种访问权限，准确的说还有一种是默认的访问权限，加上它一共四种。private...
Java基础(八)：封装、继承、多态性
从基础到源码解析的学习记录
03-26 1640
从类的定义来看，类是一类具有相同特性的事物的抽象描述。而实例变量和实例方法就是事物的特征，那么父类中声明的实例变量和实例方法代表子类事物也有这个特征。如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有空参的构造器，则。所以继承意味着子类的对象除了看子类的类模板还要看父类的类模板。问题：在创建子类对象的过程中，一定会调用父类中的构造器吗？一个引用类型变量可能指向(引用)多种不同类型的对象。特别说明：应该避免子类声明和父类重名的成员变量。问题：创建子类的对象时，内存中到底有几个对象？
Java 封装、继承、多态的理解
持 开源思想，撰 必胜所学，望 勤学者，无难处
01-06 5586
更好的阅读体验：Java封装、继承、多态的理解 1.封装 封装：就是隐藏对象的属性和实现细节，仅对外提供公共访问方式。让使用者知道的才暴露出来，不需要让使用者知道的全部隐藏起来 封装的好处：避免使用者直接操作属性值，隐藏类的实现细节；让使用者只能通过程序员规定的方法来访问数据；可以方便的加入存取控制语句，限制不合理操作，提高程序安全性。 1.1.封装的实现 Java是使用“访问控制符”来控制哪些细节需要封装的，哪些细节需要暴露的。 Java中有4种访问控制符，分别为private,defaul.
Java封装继承多态练习题
qq_44918461的博客
08-09 3281
题目描述 某公司的雇员分为以下若干类： Employee：这是所有员工总的父类， 属性：员工的姓名，员工的生日月份。 方法：getSalary(intmonth) 根据参数月份来确定工资，如果该月员工过生日，则公司会额外奖励100 元。 SalariedEmployee：Employee 的子类，拿固定工资的员工。 属性：月薪 HourlyEmployee： Employee 的子类， 按小时拿工资的员工，每月工作超出160 小时的部分按照1.5 倍工资发放。 属性：每小时的工资、每月工作的小时数 Sale
java封装继承.docx
03-31
Java 封装继承知识点总结 本文将对 Java 中的封装、继承、方法重载、方法重写、多态、抽象类和接口等概念进行详细的解释和总结。 一、封装（Encapsulation） * 作用：保护对象中的属性，避免出现无效数据 * 语法...
详解java封装继承多态
08-26
Java 封装继承多态详解 Java 中的封装、继承和多态是面向对象编程（Object Oriented Programming）三大特性。下面，我们将详细介绍这三者之间的关系和应用。 封装是指将数据和方法放入类中，并控制对数据的访问...
Java封装、继承、多态三大特征的理解
08-27
Java封装、继承、多态三大特征的理解 Java语言中的三大特征分别是封装、继承和多态，这三大特征是面向对象编程的核心概念，掌握这些特征是 Java 开发者必须具备的基本技能。 封装 封装是指隐藏对象的属性和实现...
java封装 继承与多态
10-23
java封装 继承与多态 程序设计 类与对象
详解Java中的封装、继承、多态
08-31
在Java编程语言中，封装、继承和多态是面向对象编程的三大核心概念，它们构成了Java类库设计的基础，使得代码更加模块化、可维护和复用。 **封装**是面向对象编程的基本原则之一，其目标是隐藏实现细节，提供简洁...
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 446
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 244
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 617
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
花几千上万学习Java，真没必要！（三十五）
最新发布
wehpd的博客
07-30 275
集合之Map
Java封装继承基础教程：创建与封装学生类
"Java基础封装继承PPT，适合初学者，包含封装、继承概念及应用" 在Java编程中，封装、继承和多态是面向对象编程的三大特性。封装是面向对象编程的基础，它强调的是数据保护和信息隐藏。在Java中，封装的主要目的是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值