对象三大特性：封装、继承、多态

最新推荐文章于 2023-03-26 21:04:11 发布
最新推荐文章于 2023-03-26 21:04:11 发布
阅读量70 收藏
点赞数
分类专栏： 初识Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42287451/article/details/116568534
版权
封装

在这里插入图片描述

package com.ljh.oop.Demo4;
//类 private：私有
public class Student {

    private String name;//名字
    private int id;//学号
    private char sex;//性别
    private int age;//年龄
    //提供一些可以操作这个属性的方法！
    //提供一些public 的get、set方法

    //get 获得这个数据
    public String getName() {
        return name;
    }
    //set 给这个数据设置值
    public void setName(String name) {
        this.name = name;
    }
    //alt+insert
    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.ljh.oop.Demo4;

/*
    1.提高程序的安全性，保护数据
    2.隐藏代码的实现细节
    3.统一接口
    4.系统可维护增加了
 */
public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("ljh");
        System.out.println(s1.getName());

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

在这里插入图片描述
在这里插入图片描述

Person类
package com.ljh.oop.Demo5;

//在Java中，所有的类，都直接或者间接的继承Object类
//Person 人 ：父类
public class Person {
    public Person() {
        System.out.println("Person无参执行了");
    }

    //public
    //protected
    //defaut
    //private
    private int money = 10_0000;
    protected String name = "ljh";

    public void print(){
        System.out.println("Person");
    }
    //私有的东西无法被继承
    private void print1(){
        System.out.println("Person");
    }
    public void say(){
        System.out.println("说了一句话");
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}
Student类
package com.ljh.oop.Demo5;

//学生 IS 人：派生类，子类
public class Student extends Person {
    //Ctrl+H
    private String name = "ljhdsdds";

    public Student() {
        //隐藏代码：调用了父类的无参构造，默认是无参构造
        super();//调用父类的构造器，必须要在子类构造器的第一行
        //如果想调用有参构造可以用super（“。。。”）
        System.out.println("Student无参执行了");
    }

    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        print();
        this.print();
        super.print();
    }
}
Teacher类
package com.ljh.oop.Demo5;

//学生 IS 人：派生类，子类
public class Student extends Person {
    //Ctrl+H
    private String name = "ljhdsdds";

    public Student() {
        //隐藏代码：调用了父类的无参构造，默认是无参构造
        super();//调用父类的构造器，必须要在子类构造器的第一行
        //如果想调用有参构造可以用super（“。。。”）
        System.out.println("Student无参执行了");
    }

    public void test(String name){
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.name);
    }
    public void print(){
        System.out.println("Student");
    }
    public void test1(){
        print();
        this.print();
        super.print();
    }
}
Application
package com.ljh.oop.Demo5;

public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        student.say();
        student.test("李李李");
    }
}
输出结果

在这里插入图片描述

重写（比较静态方法和非静态）差别很大

静态方法

A类
package com.ljh.oop.Demo6;

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

}
B类
package com.ljh.oop.Demo6;

public class B {
    public static void test(){
        System.out.println("B => test()");
    }
}
运行代码
package com.ljh.oop.Demo6;

public class Application {
    public static void main(String[] args) {
        //静态的方法和非静态的方法区别很大！
        //静态方法：//方法的调用只和做点定义的数据类型有关系
        A a = new A();
        a.test();

        //父类的引用指向了子类
        B b = new A();
        b.test();//B
    }
}

在这里插入图片描述

非静态方法

A类
package com.ljh.oop.Demo6;

public class A extends B {
//    public static void test(){
//        System.out.println("A => test()");
//    }
 //Override重写
    @Override//注解：有功能的注释
        public  void test(){
            System.out.println("A => test()");
        }

}
B类
package com.ljh.oop.Demo6;

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

}
运行代码
package com.ljh.oop.Demo6;

public class Application {
    public static void main(String[] args) {
        //静态的方法和非静态的方法区别很大！
        //静态方法：//方法的调用只和做点定义的数据类型有关系
        A a = new A();
        a.test();

        //父类的引用指向了子类
        B b = new A();
        b.test();//B
    }
}

在这里插入图片描述
在这里插入图片描述

多态

在这里插入图片描述

Student类
package com.ljh.oop.Demo7;

public class Student extends Person{
    @Override
    public void run() {
        System.out.println("son");
    }
    public void eat(){
        System.out.println("eat");
    }
}
Person类
package com.ljh.oop.Demo7;

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

}
运行代码
package com.ljh.oop.Demo7;

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();

        //对象能执行那些方法，主要看对象左边的类型，和右边关系不大
        ((Student)s2).eat();//子类重写了父类的方法，执行子类的方法
        s1.eat();
    }
}

在这里插入图片描述
在这里插入图片描述

instanceof

在这里插入图片描述

类型转换

在这里插入图片描述

weixin_42287451
关注
专栏目录
C# 面向对象三大特性：封装、继承、多态
09-02
在C#中，面向对象的三大特性——封装、继承和多态，是实现这一目标的关键工具。 1. 封装 封装是面向对象编程的基础，它意味着将数据和操作这些数据的方法捆绑在一起，形成一个独立的单元，即类。在C#中，我们可以...
类的三大特性-封装
陈家豪的博客
06-30 2257
（一）类的封装 （1）类的封装性 1.如果外部的类可以随意修改一个类的成员变量，可能会造成不可预料的程序错误。例如一个人的年龄，必须是在一个正常的范围内，不能被外部随意修改，如果被设成负数，则可能会出现程序错误。 2.在定义一个类的成员(包括变量和方法)时，可以使用private、protected、public等关键字说明这个成员的访问权限。 3.为了实现良好的封装性，通常将类的成员变量声明为private，再通过public的方法来对这个变量进行访问。 4.对一个成员变量，一般有读取和赋值两种操作，一般
【JavaSE】类与对象--封装性
weixin_50486535的博客
11-22 1608
封装性是面向对象编程中的三大特征之一,封装性就是把对象的成员属性和成员方法结合成一个独立的相同单位，并尽可能隐蔽对象的内部细节。
Java类的三大特性之一：封装性
瓦坎达会议室
03-29 6459
阿萨德大奥所
Java基础(八)：封装、继承、多态性
最新发布
从基础到源码解析的学习记录
03-26 1862
从类的定义来看，类是一类具有相同特性的事物的抽象描述。而实例变量和实例方法就是事物的特征，那么父类中声明的实例变量和实例方法代表子类事物也有这个特征。如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有空参的构造器，则。所以继承意味着子类的对象除了看子类的类模板还要看父类的类模板。问题：在创建子类对象的过程中，一定会调用父类中的构造器吗？一个引用类型变量可能指向(引用)多种不同类型的对象。特别说明：应该避免子类声明和父类重名的成员变量。问题：创建子类的对象时，内存中到底有几个对象？
Java中类的封装，三大特性之一
记录学习JAVA中的点点滴滴
10-20 960
举例来说：就如我们平时使用的电脑，我们不需要知道电脑内部具体的硬件cpu，显卡，内存大小型号等。电脑厂商就把这些用机箱封起来，我们只需要使用机箱对外提供的usb，鼠标，显示屏接口就可以，这样是不是就很方便。java封装是指在创建一个类的时候，将类中的属性私有化，也就是使用private关键字修饰，私有属性不允许外界去访问，只能通过该类提供的方法来访问这些私有属性。java中的封装是java三大特性之一，另外两个特性是继承和多态。
Java开发中的三大特性：封装继承与多态的学习
06-11
在Java开发中，封装、继承和多态是面向对象编程的三大核心特性，它们为程序设计提供了灵活性和可扩展性。 **封装**是面向对象编程的基础，它指的是将数据和操作数据的方法绑定在一起，作为一个独立的单元，也就是...
Java面向对象三大特性，即封装、继承、多态
12-23
面向对象三大特性知识模板 大家好，我是Ziph！ 今天分享下面向对象三大特性的知识内容。 结合思维导图学习效果更佳！点击下方链接进入 Java面向对象三大特性思维导图 一、封装 封装的必要性：在对象的外部为对象的...
php 三大特点：封装，继承，多态
12-17
它支持面向对象编程，其中封装、继承和多态是其核心的三大特性。这些特性使得PHP能够构建更加灵活、可维护和可扩展的代码结构。 **封装**是面向对象编程的基本原则之一，它的目的是保护数据的安全性，防止外部代码...
类的封装性
xiaoqichuan的博客
08-22 315
类的封装其实就是封装其属性和方法，然后通过get、set方法去访问类内部。 封装属性：private 属性类型 属性名 封装方法：private 方法返回类型 方法名称（参数） 举例： 未封装时，可以通过对象直接去调用属性或方法 class Person { String name; int age; public void talk() { System.out....
类的三大特性之-----封装
断翅的鸟依旧拼命的飞
06-10 613
——–对于新手来说，封装听起来是不是就好像打包的意思呢？的确，当初我刚刚接触面向对象语言的时候，记得第一次听到封装一词，我就在琢磨，封装？好像都是一些货物需要打包装箱，这代码为什么要封装呢，当时就懵了！不过还好，由于老师耐心的讲解，终于化开了我的疑虑，哈哈。封装： 是把过程和数据包围起来，对数据的访问只能通过已定义的接口。当然还不止这些，封装主要是使用方法将类的数据隐藏起来，控制用户对类的修改和访
面向对象的特点，封装性，继承性，多态性！
热门推荐
茕夜
01-29 1万+
1.面向对象程序设计有三大特点，分别是封装，继承，多态，接下来就介绍一下这三个特点，积累一下。 2.封装，封装是面向对象编程的核心思想，将对象的属性和行为封装起来，而将对象的属性和行为封装起来的载体是类，类通常对用户隐藏其实现的细节，这就是封装的思想，在Java中通常通过建立一个实体类，用来封装对象的属性和行为，通过setXxx()和getXxx()方法封装起来，例如，用户在使用一款软件的时候，
java 简述类的封装性、继承性、多态性
王如霜
09-22 4149
一：什么是封装性、继承性、多态性          封装性：通俗说就是一个盒子，多个对象、功能、组件等装在一个盒子里，内部具体是什么不知道，用到它时，使用特定方法或功能去调用它。即声明一个变量（其属性值是private）不能给其变量直接赋值，但可以通过方法构造去复制。意思近似于软件工程中讲到的黑盒测试。         继承性：通俗说就是实际生活中儿子与父亲就是继承关系，制作了一台电脑，再想生
java的封装性
在黑夜中前行
12-03 3896
目的限制在类的外部对类内部成员进行访问，只通过公共接口来访问类的成员数据。 屏蔽细节：这是程序设计的基本思想，便于程序功能的扩展和程序的维护。 封装类大多数变量都是私有的，变量通过他们自己类的方法修改，一个类只向其它类公开一部分成员（通常是方法）作为接口； 若变量或方法为公有，它就是接口的一部分，其它类可以访问它；若为私有，它是实现的一部分，只有类自己的成员可以访问它。 访问控制符Java通过访问控
C++-类、封装性、成员函数
可可西里
02-09 1671
类struct将所有成员都默认为public权限，这很不安全。因此C++引进了功能与struct相同但更安全的数据类型——类。说明： 类声明中的访问限定符没有先后次序，通常将private放在后面，将public放在前面，方便了解类的可访问接口。 同一个类中，访问限定符出现次数没有限制。 数据成员和成员函数都可以设置为public、private、protected属性。 数据成员可以是任何数据类型
类的三大要素：封装性、继承、多态
ProgreamA的博客
06-23 3103
类的学习总结 类分为封装，继承，多态 类的封装性：类防止像结构体一样被外部修改所以类就有封装性，默认的class如果没有声明的话一般就是private的这样的数据成员只能用该类里面的成员函数进行访问，public的成员可以在类外进行直接访问没有安全性，protect成员只能是该类能对这种数据成员进行访问，在别的类里面无法进行访问同样需要调用函数，还有就是类里面的函数一定要有返回值，否则没法改动原来...
浅谈C++中的类与封装性
gaorutao0923的博客
11-25 1079
类 我们知道，在C语言中struct将所有成员都默认为public权限，这很不安全。因此C++引进了功能与struct相同但更安全的数据类型——类。说明： 1.类声明中的访问限定符没有先后次序，通常将private放在后面，将public放在前面，方便了解类的可访问接口。 2.同一个类中，访问限定符出现次数没有限制。 3.数据成员和成员函数都可以设置为pub...
Java面向对象三大特性：继承、多态与封装解析
在Java编程中，基础知识构成了整个编程体系的基石，而Java的三大特性——继承、多态和封装，更是理解面向对象编程的关键。 1. **继承**： 继承是面向对象编程的一大特征，允许一个类（子类）从另一个类（父类）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

weixin_42287451

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

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

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

打赏作者

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

抵扣说明：

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

余额充值