封装，继承（方法的重写），多态（instanceof；类型转换）

最新推荐文章于 2024-11-13 17:07:29 发布
最新推荐文章于 2024-11-13 17:07:29 发布
阅读量206 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lxy13263050001/article/details/122435918
版权

封装

  • 该露的露，该藏的藏

    • 我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用

  • 封装（数据的隐藏）

    • 通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏

  • 属性私有，get/set

  • package com.mao.oop.demo04;

//类 private:私有
public class Student {

    //属性私有
    private String name;//名字
    private int id;//学号
    private char sex;//性别
    private int age;//年龄

    //提供一些可以操作这个属性的方法！
    //提供一些public的get、set方法

    //get 获得这个数据
    public String getName(){
        return this.name;
    }

    //set 给这个数据设置值
    public void setName(String name){
        this.name = name;
    }

    //alt + insert可以自动生成get set方法
    public int getId() {
        return id;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age>120 || age<0){
            this.age = 3;
        }else{
            this.age = age;
        }

    }
}
/*
    package com.mao.oop;


import com.mao.oop.demo04.Student;

    /*
    1.提高程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.系统的可维护性增加了
     */

/*
//一个项目一个只存在一个main方法
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();

        s1.setName("大猫");

        //方法名，参数列表
        System.out.println(s1.getName());

        s1.setAge(999);//不合法的
        System.out.println(s1.getAge());
    }
}
 */

继承

  • 继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模

  • extends的意思是“扩展”。子类是父类的扩展

  • JAVA中类只有单继承，没有多继承

  • 继承是类和类之间的一种关系。除此之外，类和类之间的关系还有依赖、组合、聚合等

  • 继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用关键字extends来表示

  • 子类和父类之间，从意义上讲具有“is a”的关系

  • object类

  • super

    • super注意点：
    1.super调用父类的构造方法，必须在构造方法的第一个
    2.super必须只能出现在子类的方法或者构造方法中！
    3.super和this不能同时调用构造方法！

Vs this:
    代表的对象不同：
        this：本身调用者这个对象
        super：代表父类对象的应用
    前提
        this：没有继承也可以使用
        super：只能在继承条件才能使用
    构造方法
        this()；本类的构造
        super()：父类的构造

  • 方法重写

  • package com.mao.oop.demo05;

//重写都是方法的重写，和属性无关
public class B {

    public void test(){
        System.out.println("B=>test()");
    }
}

重写：需要有继承关系，子类重写父类的方法！
    1.方法名必须相同
    2.参数列表必须相同
    3.修饰符：范围可以扩大：public > protected > default > private
    4.抛出的异常：范围，可以被缩小，但不能扩大  ClassNotFoundException --> Exception（大）

重写，子类的方法和父类必须要一致，方法体不同！

为什么要重写：
    1.父类的功能，子类不一定需要，或者不一定满足！
    Alt + Insert    ：   override

多态

  • 动态编译：类型：可扩展性

  • 即同一方法可以根据发送对象的不同而采用多种不同的行为方式

  • 一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多

  • 多态存在的条件

    • 有继承关系
    • 子类重写父类方法
    • 父类引用指向子类对象

  • 注意：多态是方法的多态，属性没有多态性

    • package com.mao.oop.demo06;

public class Person {

    public void run(){

    }
}

package com.mao.oop.demo06;

public class Student extends Person {

    @Override
    public void run() {
        System.out.println("son");
    }

    public void eat(){
        System.out.println("吃");
    }
}
    /*
    多态注意事项：
    1.多态是方法的多态，属性没有多态
    2.父类和子类，有联系 类型转换异常  ClassCastException
    3.存在条件：继承关系，方法需要重写，父类引用指向子类对象   Father f1 = new Son();

        1.static    方法，属于类，不属于实例
        2.final     常量：
        3.private   方法
     */

package com.mao.oop;


import com.mao.oop.demo06.Person;
import com.mao.oop.demo06.Student;

//一个项目一个只存在一个main方法
public class Application {
    public static void main(String[] args) {


        //一个对象的实际类型是确定的
        //new Student();
        //new Person();

        //可以指向的引用类型就不确定了：父类的引用指向子类

        //Student能调用的方法都是自己的或者是继承父类的
        Student s1 = new Student();
        //Person父类型，可以指向子类，但是不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        s2.run();//子类重写了父类的方法，就指向子类的方法
        s1.run();//

        //对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
//        s2.eat();
        ((Student)s2).eat();//通过强制类型转换可以调用Student的方法
        s1.eat();
    }

}

  • instanceof

    • package com.mao.oop.demo06;

public class Person {

}

package com.mao.oop.demo06;

public class Student extends Person {


}

package com.mao.oop.demo06;

public class Teacher extends Person {
}

package com.mao.oop;


import com.mao.oop.demo06.Person;
import com.mao.oop.demo06.Student;
import com.mao.oop.demo06.Teacher;

//一个项目一个只存在一个main方法
public class Application {
    public static void main(String[] args) {

        //Object > Person > Student
        Object object = new Student();

        //System.out.println(X instanceof Y);//能不能编译通过！

        System.out.println(object instanceof Student);//true
        System.out.println(object instanceof Person);//true
        System.out.println(object instanceof Object);//true
        System.out.println(object instanceof Teacher);//false
        System.out.println(object instanceof String);//false
        System.out.println("=====================");
        Person person = new Student();
        System.out.println(person instanceof Student);//true
        System.out.println(person instanceof Person);//true
        System.out.println(person instanceof Object);//true
        System.out.println(person instanceof Teacher);//false
        //System.out.println(person instanceof String);//编译报错！
        System.out.println("=====================");
        Student student = new Student();
        System.out.println(student instanceof Student);//true
        System.out.println(student instanceof Person);//true
        System.out.println(student instanceof Object);//true
        //System.out.println(student instanceof Teacher);//编译报错
        //System.out.println(student instanceof String);//编译报错！

    }

}

  • 类型转换

    • package com.mao.oop.demo06;

public class Person {

    public void run(){
        System.out.println("run");
    }
}

package com.mao.oop.demo06;

public class Student extends Person {
    public void go(){
        System.out.println("go");
    }

}

package com.mao.oop.demo06;

public class Teacher extends Person {
}

package com.mao.oop;


import com.mao.oop.demo06.Person;
import com.mao.oop.demo06.Student;

//一个项目一个只存在一个main方法
public class Application {
    public static void main(String[] args) {
        //类型之间的转化：父     子

        //高                     低
        Person obj = new Student();

        //student将这个对象转换为Student类型，我们就可以使用Student类型的方法了
        ((Student) obj).go();//1
        Student student = (Student) obj;//2
        student.go();

        //子类转父类，可能会丢失自己本来的一些方法
        Student student1 = new Student();
        student.go();
        Person person = student1;

    }
}
    /*
    1.父类引用指向子类的对象
    2.把子类转换为父类，向上转型：
    3.把父类转换为子类，向下转型：需要强制转换
    4.方便方法的调用，减少重复的代码！可以使代码变得简洁
     */
九命猫小宇
关注
Java基础：封装、继承、重写、多态以及类型转换
iOS逆向与安全
04-18 3288
引言 APP商户终端采购订单 智、坤楠 开发 接口
【Java】封装、继承与多态
m0_50987960的博客
10-29 2034
封装、继承、多态与四种访问修饰符
封装，继承，多态，instanceof，类型转换
suewo的博客
01-21 416
一：封装大多数时候是对于属性而言，方法用的封装较少 关键字private(与public相对) public class Demo01 { private String name;//属性私有。 private int num; private char sex } 给属性加上private，则其他类中不能再实例化了，如图，报错。 使用public的get/set来提供一些可以操控这些私有属性的方法。 get：获取数据。 set：给这个数据设置值 ...
封装、继承、多态
Tower_SHR的博客
06-23 728
文章目录面向对象的封装性为什么封装怎么封装面向对象的继承性 面向对象的封装性 为什么封装 新建两个类：用户类、用户测试类 package day01.encapsulation; /** * @author 衣鱼 *用户类 */ public class User { int age; } package day01.encapsulation; /** * @author 衣鱼 *用户的测试类 * user类中的age属性在外部程序中可以随意访问，导致age属性 * 不安全。用户年龄被
java 类型转换重写_java笔记之封装、继承、重写、多态以及类型转换
weixin_31572189的博客
02-25 139
前言今天来谈谈Java中面向对象的主要的具体表现即封装，继承和多态。这是基础的重点。正文封装隐藏实现细节1)封装的步骤：1))将属性私有化，使用private修饰符，修饰需要隐藏的方法和属性2))提供共有的方法，访问私有属性(getter,setter)注：封装的目的是减少类与类的关联度2)封装的规范：1))修饰属性的可见度，来限制对属性的访问2))为每个属性创建一对赋值和取值方法3))在sett...
Java之封装、继承，多态
weixin_74200123的博客
07-12 1238
详细的介绍了java中的三大特性，封装、继承、多态。
面向对象编程三大特性—封装、继承和多态
m0_58006481的博客
08-21 1789
1.封装：private； 2.继承：protected继承访问权限、四大访问权限、super vs this、对象实例化流程 3.向上/向下转型、方法重写、instanceof关键字（规避类型转换异常的错误） 4.final关键字 5.多态
java封装、继承、多态
2301_80803762的博客
05-25 964
可以认为封装是一层保护，防止类中代码和数据被外部随意访问，提供有接口，使用该类数据，增强了。
JAVA 常用方法实例 多态 instanceof 和 类型转换
望天吼
01-25 221
JAVA 常用方法实例 instanceof 和 类型转换
Java系列——封装、继承、多态初了解
wct040923的博客
05-06 9961
封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。将类的某些信息隐藏在类的内部，不允许外部程序进行直接的访问调用。通过该类提供的方法来实现对隐藏信息的操作和访问。隐藏对象的信息。留出访问的对外接口。​ 举个比较通俗的例子，比如我们的USB接口。如果我们需要外设且只需要将设备接入USB接口中，而内部是如何工作的，对于使用者来说并不重要。而USB接口就是对外提供的访问接口。
Java 封装 继承 多态（深入理解）
2302_79806056的博客
03-08 4500
详细解析了面向对象编程（java）的三大特性：封装继承和多态（超详细）收藏精品，帮助加深理解
面向对象-封装、继承与多态
Sapphire_Veg的博客
04-18 1951
继承有延续（下一代延续上一代的基因、财富）、扩展（下一代和上一代又有所不同）的意思。多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类中无需再定义这些属性和行为，只需要和抽取出来的类构成某种关系。其中，多个类可以称为子类，也叫派生类；多个类抽取出来的这个类称为父类超类（superclass）或者基类。
封装、继承、多态的详细说明
geist_的博客
06-20 3127
详细说明 继承、多态 还有其包含的小知识点以及其代码的实现
封装、继承与多态学习总结
Throbs的博客
07-26 443
继承与多态、封装共为面向对象的三个基本特征。继承可以使得子类具有父类的属性和方法或者重新定义、追加属性和方法等。以上则是我所学习面向对象三大特征的基本总结，可能还有所欠缺，但学习面向对象最重要的是思想的转变，理解起来会比较抽象，但打好基础比任何东西都重要。当然面向对象还有很多的内容以及延伸，后期还会务实自己的学习方式，呈现出更好的作品，希望正在观看的你支持一下，一起学习成长。.........
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 300
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
Java基础07
m0_74977981的博客
11-11 695
如图下图：每个case中都有一个break，如果没有这个break，就不会跳出case，直到遇见break为止。
SpringBoot(五)
最新发布
₍˄·͈༝·͈˄*₎◞ ̑̑的博客
11-13 795
Rest请求处理
SpringBoot 实现图片加水印
心猿意码
11-11 400
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
刷题---顺序表算法题
weixin_63997543的博客
11-11 444
顺序算法题----力扣刷题
Java继承与抽象详解：重写、多态与类型转换
本篇Java笔记主要关注继承与抽象这两个...这篇笔记深入讲解了Java中的继承机制、重写规则、`super`的用法、基础类如`Object`的作用，以及多态性和类型转换的概念。这些知识点对于理解和运用Java面向对象编程至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

九命猫小宇

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值