Java : 封装、继承、多态

已于 2023-03-25 21:56:25 修改
阅读量283 收藏 7
点赞数 5
分类专栏： Java 文章标签： java 开发语言
于 2023-03-25 17:43:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64552046/article/details/129657768
版权

目录标题

封装

封装的概念

封装:将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
例如:计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。

访问限定符

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符：
可以修饰方法/成员/类

No范围privatedefaultprotectedpublic
1同一包中的同一类YesYesYesYes
2同一包中的不同类YesYesYes
1不同包中的子类YesYes
1不同包中的非子类Yes

public：可以理解为一个人的外貌特征，谁都可以看得到
default: 对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了
private：只有自己知道，其他人都不知道(被private修饰的属性,只能在当前类当中使用。什么是当前类?找大括号->类的大括号)

封装扩展之包

包的概念
为了更好的管理类，把多个类收集在一起成为一组，称为软件包。包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。
在这里插入图片描述
导入包中的类

//但是这种写法比较麻烦一些, 可以使用 import语句导入包.例如:import java.util.Date;
//如果需要使用 java.util 中的其他类, 可以使用 import java.util.*
public class Test1 {
    public static void main(String[] args) {
        java.util.Date date = new java.util.Date();// 得到一个毫秒级别的时间戳
        System.out.println(date.getTime());
    }
}
//但是我们更建议显式的指定要导入的类名. 否则还是容易出现冲突的情况.
//如果util包和sql包都存在一个Date这样的类，就会出现歧义，编译出错，编译器也不知道要导入哪一个包中的类

import 和 C++ 的 #include 差别很大. C++ 必须 #include 来引入其他文件内容, 但是 Java 不需要。import 只是为了写代码的时候更方便. import 更类似于 C++ 的 namespace 和 using。

自定义包

  • 在文件的最上方加上一个 package 语句指定该代码在哪个包中
  • 包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.baidu1 ).
  • 包名要和代码路径相匹配. 例如创com.baidu1 的包, 那么会存在一个对应的路径 com/demo1 来存储代码.
    如果一个类没有 package 语句, 则该类被放到一个默认包中.

如何新建一个包?

  1. 在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包
  2. 在弹出的对话框中输入包名, 例如 com.baidu
  3. 在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名即可
  4. 在新创建的 Test.java 文件的最上方, 就出现了一个 package 语句
//package声明java文件在哪个包当中
package com.baidu;
public class Test3 {
    String name = "zhangsan";
}
//----------------------------
//同一个包中不同类可以访问
package com.baidu;
public class Test {
    public static void main(String[] args) {
        Test3 test3 = new Test3();
        System.out.println(test3.name);
    }
}
//------------------------------
//不同包不能访问
package com.baidu.baidu2;
import com.baidu.Test3;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: 86191
 * Date: 2023-03-20
 * Time: 15:38
 */
public class Test2 {
    public static void main(String[] args) {
        Test3 test3 = new Test3();
        System.out.println(test3.name);
    }
}

包的访问控制权限控制举例

//Test1位于com.baidu1包中，Test2位于com.baidu2
package com.baidu1;

import com.baidu2.Test2;
public class Test1 {
    public static void main(String[] args) {
        Test2 test2 = new Test2();
        System.out.println(test2.age);
        //System.out.println(test2.name);//会报错，name是default，不允许被其他包中的类访问
        System.out.println(test2.sex);//sex是私有的，不允许被其他类访问
    }
}

//--------------------------------------------
package com.baidu2;

import com.baidu1.Test1;
public class Test2 {
    String name = "张三";//不加访问权限默认是default
    public int age = 10;
    private String sex = "男";
}

继承

继承概念

继承(inheritance)机制：允许在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构， 体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。

继承语法
修饰符 class 子类 extends 父类 {
// …
}

class Animal {
    public String name;
    public int age;
    public void eat() {
        System.out.println(name+" 正在吃饭");
    }
    public void sleep() {
        System.out.println(name+"正在睡觉");
    }
}
class Dog {
    //public String name;
    //public int age;
    public float weight;
    /*public void eat() {
        System.out.println(name+" 正在吃饭");
    }
    public void sleep() {
        System.out.println(name+"正在睡觉");
    }*/
    public void bark() {
        System.out.println(name+" 正在汪汪");
    }
}
class Cat {
    //public String name;
    //public int age;
    public String hair;
    /*public void eat() {
        System.out.println(name+" 正在吃饭");
    }
    public void sleep() {
        System.out.println(name+"正在睡觉");
    }*/
    public void CatchMouse() {
        System.out.println(name+" 正在抓老鼠");
    }
}
public class Test {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //dog类中并没有定义任何成员变量，name和age属性肯定是从父类Animal中继承下来的
        System.out.println(dog.name);
        System.out.println(dog.age);
        //dog访问的eat()和sleep()方法也是从Animal中继承下来的
        dog.eat();
        dog.sleep();
        dog.bark();
    }
}

在这里插入图片描述

  1. 子类会将父类中的成员变量或者成员方法继承到子类中了
  2. 子类继承父类之后，要新添加自己特有的成员，体现出与基类的不同。

Dog和Cat都继承了Animal类，其中：Animal类称为父类/基类或超类，Dog和Cat可以称为Animal的子类/派生类，继承之后，子类可以复用父类中成员，子类在实现时只需关心自己新增加的成员即可。
继承概念中可以看出继承最大的作用就是：实现代码复用

父类成员访问

子类中访问父类的成员变量

class Base {
    int a;
    int b;
    int c;
}
class Derived extends Base{
    int a = 199; // 与父类中成员a同名，且类型相同
    int b; // 访问从父类中继承下来的b
    public void method(){
        System.out.println(a); // 访问自己的a
        System.out.println(super.a);//通过super可以访问父类的成员的a
        System.out.println(c); // 子类没有c，访问的肯定是从父类继承下来的c
         System.out.println(d); //  编译失败，因为父类和子类都没有定义成员变量b
    }
}
public class Test1 {
    public static void main(String[] args) {
        Derived derived = new Derived();
        derived.method();
    }
}

在子类方法中 或者 通过子类对象访问成员时：

  • 如果访问的成员变量子类中有，优先访问自己的成员变量。
  • 如果访问的成员变量子类中无，则访问父类继承下来的，如果父类也没有定义，则编译报错。
  • 如果访问的成员变量与父类中成员变量同名，则优先访问自己的

成员变量访问遵循就近原则，自己有优先自己的，如果没有则向父类中找。

子类中访问父类的成员方法

class Base1 {
    int a;
    int b;
    public void methodA() {
        System.out.println("AAA");
    }
     public void methodB() {
        System.out.println("DDD");
    }
}
class Derived1 extends Base1{
    int a = 199; // 与父类中成员a同名，且类型相同
    int b; // 与父类中成员b同名，但类型不同
    int c;
    public void method() {
        System.out.println("CCC");
    }
    //methodA(char ch)和父类methodA()构成了重载,说明了方法的重载不一定要在同一个类中
    public void methodA(char ch) {
        System.out.println("BBB");
    }

    public void test() {
        methodB();//子类没有，调用父类的
        method();//当子类没有不带参数的method的方法时候就会调用父类
        method('c');//子类有带参数的method方法时，就会调用子类的method方法
    }
}

public class Test2 {
    public static void main(String[] args) {
        Derived1 derived = new Derived1();
        derived.test();
    }
}
  • 通过子类对象访问父类与子类中不同名方法时，优先在子类中找，找到则访问，否则在父类中找，找到则访问，否则编译报错。
  • 通过派生类对象访问父类与子类同名方法时，如果父类和子类同名方法的参数列表不同(重载)，根据调用方法适传递的参数选择合适的方法访问，如果没有则报错；

总结：成员方法没有同名时，在子类方法中或者通过子类对象访问方法时，则优先访问自己的，自己没有时再到父类中找，如果父类中也没有则报错.

super关键字

super关键字，该关键字主要作用：在子类方法中访问父类的成员。

//在子类方法中，如果想要明确访问父类中成员时，借助super关键字即可
class Base2 {
    int a;
    int b;
    public void methodA() {
        System.out.println("AAA");
    }
    public void methodB() {
        System.out.println("访问父类类中的methodB()");
    }
}
class Derived2 extends Base2{
    int a = 199;//  与父类中成员变量同名且类型相同
    int b;
    int c;
    public void methodB() {
        System.out.println("BBB");
    }
    public void methodA(char ch) {
        System.out.println("AAA");
    }
    public void test() {
        System.out.println(super.a);//访问父类成员中的a
        methodA('c');//访问子类中的methodA()
        super.methodB();//访问父类中methodB()
    }
}

public class Test3 {
    public static void main(String[] args) {
        Derived2 derived = new Derived2();
        derived.test();
    }
}
  1. 只能在非静态方法中使用
  2. 在子类方法中，访问父类的成员变量和方法。

子类构造方法

父子父子，先有父再有子，即：子类对象构造时，需要先调用基类构造方法，然后执行子类的构造方法。

class Base4 {
    public Base4() {
        System.out.println("Base()");
    }
}
class Derived4 extends Base4{
    public Derived4(){
    // super(); // 注意子类构造方法中默认会调用基类的无参构造方法：super(),
    // 用户没有写时,编译器会自动添加，而且super()必须是子类构造方法中第一条语句，
    // 并且只能出现一次
        System.out.println("Derived()");
    }
}
public class Test {
    public static void main(String[] args) {
        Derived4 d = new Derived4();
    }
}

在子类构造方法中，并没有写任何关于基类构造的代码，但是在构造子类对象时，先执行基类的构造方法，然后执行子类的构造方法，因为：子类对象中成员是有两部分组成的，基类继承下来的以及子类新增加的部分 。父子父子肯定是先有父再有子，所以在构造子类对象时候 ，先要调用基类的构造方法，将从基类继承下来的成员构造完整，然后再调用子类自己的构造方法，将子类自己新增加的成员初始化完整

  1. 若父类显式定义无参或者默认的构造方法，在子类构造方法第一行默认有隐含的super()调用，即调用基类构造方法
  2. 如果父类构造方法是带有参数的，此时需要用户为子类显式定义构造方法，并在子类构造方法中选择合适的父类构造方法调用，否则编译失败。
  3. 在子类构造方法中，super(…)调用父类构造时，必须是子类构造函数中第一条语句。
  4. super(…)只能在子类构造方法中出现一次，并且不能和this同时出现

super和this的区别

super和this都可以在成员方法中用来访问：成员变量和调用其他的成员函数，都可以作为构造方法的第一条语句，那他们之间有什么区别呢？

相同点:

  1. 都是Java中的关键字
  2. 只能在类的非静态方法中使用，用来访问非静态成员方法和字段
  3. 在构造方法中调用时，必须是构造方法中的第一条语句，并且不能同时存在

不同点:

  1. this是当前对象的引用，当前对象即调用实例方法的对象，super相当于是子类对象中从父类继承下来部分成员的引用
  2. 在非静态成员方法中，this用来访问本类的方法和属性，super用来访问父类继承下来的方法和属性
  3. 在构造方法中：this(…)用来调用本类的构造方法，super(…)用于调用父类构造方法，两种调用不能同时在构造方法中出现
  4. 构造方法中一定会存在super(…)的调用，用户没有写编译器也会增加，但是this(…)用户不写则没有

protected关键字

  1. 声明为protected的方法和成员变量能被同一个包里的所有类所访问，就像默认修饰符package一样。
  2. 能被该类的子类所访问，子类可以和父类不在一个包中。
  3. 能被该类的子类所访问，子类可以和父类不在一个包中。
  4. 在子类中，子类实例可以访问其从基类继承而来的protected方法，而不能访问基类实例的protected方法。
package Demo2;
public class Test1 {
    protected int a = 199;

    public static void main(String[] args) {
        Test1 test1 = new Test1();
        System.out.println(test1.a);
    }
}

//---------------------------------
package Demo2;
public class Test2 {
    public static void main(String[] args) {
        Test1 test1 = new Test1();
        System.out.println(test1.a);
    }
}

//---------------------------------
package Demo3;
import Demo2.Test1;
public class Test3  extends Test1 {
    public void func() {
        System.out.println(super.a);
    }
    public static void main(String[] args) {
        Test3 test3 =new Test3();
        test3.func();
    }
}

多态

多态的概念&重写&多态实现条件

多态的概念：就是多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态。
在这里插入图片描述
总的来说：同一件事情，发生在不同对象身上，就会产生不同的结果。

重写

 class Animal {
    String name;
    int age;
    public Animal(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name + "吃饭");
    }
}
 class Cat extends Animal{
    public Cat(String name, int age){
        super(name, age);
    }
    public void eat(){
        System.out.println(name+"吃鱼~~~");
    }
}
 class Dog extends Animal {
    public Dog(String name, int age){
        super(name, age);
    }
    //与父类中的public void eat()方法重写
    public void eat(){
        System.out.println(name+"吃骨头~~~");
    }
}
public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat("元宝",2);
        Dog dog = new Dog("小七", 1);
        dog.eat();
    }
}

重写(override)：也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

  • 子类在重写父类的方法时，一般必须与父类方法原型一致： 返回值类型 方法名 (参数列表) 要完全一致
  • 子类的访问修饰限定符一定要大于等于父类的访问修饰限定符。例如：如果父类方法被public修饰，则子类中重写该方法就不能声明为 protected(private <包访问权限<protected<public)
  • 父类被static、private修饰的方法、构造方法都不能被重写。
  • 重写的方法, 可以使用 @Override 注解来显式指定. 有了这个注解能帮我们进行一些合法性校验. 例如不小心将方法名字拼写错了 (比如写成 aet), 那么此时编译器就会发现父类中没有 aet 方法, 就会编译报错, 提示无法构成重写.

在这里插入图片描述

//动态绑定：也称为后期绑定(晚绑定)，即在编译时，不能确定方法的行为，需要等到程序运行时，才能够确定具体调用那个类的方法
 class Animal {
    String name;
    int age;
     Animal(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name + "吃饭");
    }
}

 class Dog extends Animal {
    public Dog(String name, int age){
        super(name, age);
    }
    public void eat(){
        System.out.println(name+"吃骨头~~~");
    }
}
public class Test {
     public static void eat(Animal a) {
         a.eat();
     }
    public static void main(String[] args) {
        /* Dog dog = new Dog("wangcai",10);
        Animal animal = dog;*/
        Animal animal1 = new Dog("wangwang",11);
        animal1.eat();
        //1.父类与子类发生了重写
        //2.通过父类的引用调用eat方法，发生动态绑定
    }
}
//运行结果:
//wangwang吃骨头~~~

//-------------------------------------
//静态绑定:称为前期绑定(早绑定)，即在编译时，根据用户所传递实参类型就确定了具体调用那个方法。典型代表函数重载
public class Test2 {
    public int x;
    public int y;
    public int getx() {
        return x;
    }
    public int gety() {
        return y;
    }
    public int add(int a,int b) {
        return a+b;
    }
    public int add(int a,int b,int c) {
        return a+b+c;
    }
    public static void main(String[] args) {
        Test2 test2 = new Test2();
        int sum1 = test2.add(1,2);
        int sum2 = test2.add(1,2,3);
        System.out.println("sum1 = " + sum1);
        System.out.println("sum2 = " + sum2);
    }
}

多态的实现条件

  1. 必须在继承体系下
  2. 子类必须要对父类中方法进行重写
  3. 通过父类的引用调用重写的方法
//多态体现：在代码运行时，当传递不同类对象时，会调用对应类中的方法
class Animal1 {
    String name;
    int age;
    public Animal1(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name + "吃饭");
    }
}
class Cat1 extends Animal{
    public Cat1(String name, int age){
        super(name, age);
    }
    public void eat(){
        System.out.println(name+"吃鱼~~~");
    }
}
class Dog1 extends Animal {
    public Dog1(String name, int age){
        super(name, age);
    }
    //与父类中的public void eat()方法重写
    public void eat(){
        System.out.println(name+"吃骨头~~~");
    }
}
public class Test2 {
    // 编译器在编译代码时，并不知道要调用Dog还是Cat中eat的方法
    // 等程序运行起来后，形参animal引用的具体对象确定后，才知道调用那个方法
   // 注意：此处的形参类型必须时父类类型才可以
    public static void eat(Animal animal){
        animal.eat();
    }
    public static void main(String[] args) {
        Cat1 cat = new Cat1("旺财",2);
        Dog1 dog = new Dog1("阿七", 1);
        eat(dog);
        eat(cat);
    }
}

总结:父类引用 引用子类对象，当引用的子类对象不一样的时候，通过这个给父类引用调用父类和在子类重写的方法的时候，此时同一个引用呈现出来了不同的状态，我们把这个思想叫做多态

向上转型和向下转型

向上转型
向上转型：实际就是创建一个子类对象，将其当成父类对象来使用

语法格式：父类类型 对象名 = new 子类类型()
Animal animal = new Cat(“张三”,2);

animal是父类类型，但可以引用一个子类对象，因为是从小范围向大范围的转换。

//使用场景
//1. 直接赋值 
Animal animal1 = new Dog("wangwang",11);
//2. 方法传参
 public static void eat(Animal animal){
        animal.eat();
    }
//3. 方法返回
 public static Animal getAnimal() {
        return new Dog();
}
//向上转型的优点：让代码实现更简单灵活。
//向上转型的缺陷：不能调用到子类特有的方法

//将一个子类对象经过向上转型之后当成父类方法使用，再无法调用子类的方法，但有时候可能需要调用子类特有的方法，此时：将父类引用再还原为子类对象即可，即向下转换。
class Animal1 {
    String name;
    int age;
    public Animal1(String name, int age){
        this.name = name;
        this.age = age;
    }
    public void eat(){
        System.out.println(name + "吃饭");
    }
}
class Cat1 extends Animal{
    public Cat1(String name, int age){
        super(name, age);
    }
    public void eat(){
        System.out.println(name+"吃鱼~~~");
    }
    public void mimi() {
        System.out.println(name+"咪咪叫");
    }
}
class Dog1 extends Animal {
    public Dog1(String name, int age){
        super(name, age);
    }
    //与父类中的public void eat()方法重写
    public void eat(){
        System.out.println(name+"吃骨头~~~");
    }
    public void bark() {
        System.out.println(name+"汪汪汪");
    }
}
public class Test2 {
    public static void main(String[] args) {
        Animal animal = new Dog1("wangcai",1);
//animal本来指向的就是狗，因此将animal还原为狗也是安全的
        Dog1 dog = (Dog1) animal;//强制类型转换为Dog
        dog.bark();
//程序可以通过编程，但运行时抛出异常---因为：animal实际指向的是狗
//现在要强制还原为猫，无法正常还原，运行时抛出:ClassCastException
        //Cat1 cat1 = (Cat1) animal;
        //cat1.mimi();
        
//向下转型用的比较少，而且不安全，万一转换失败，运行时就会抛异常。Java中为了提高向下转型的安全性，引入了 instanceof ，如果该表达式为true，则可以安全转换。
if (animal instanceof Cat) {
            Cat1 cat1 = (Cat1) animal;
            cat1.mimi();
        }
    }
    //instanceof判断其左边对象是否为其右边类的实例，返回的是boolean类型的数据

多态的优缺点

优点:

  1. 能够降低代码的 “圈复杂度”, 避免使用大量的 if - else
  2. 可扩展能力更强

缺点:

  1. 属性没有多态性
    父类引用只能访问父类的方法和属性，而不能访问子类特有的方法和属性。如果需要访问子类特有的方法和属性，就需要进行类型强制转换。
    2.在构造方法中调用重写的方法
class B {
    public B() {
        func();
    }
    public void func() {
        System.out.println("B.func()");
    }
}
class D extends B {
    private int num = 1;
    @Override
    public void func() {
        System.out.println("D.func() " + num);
        //D这个对象没有构造完成，所以num还没有被初始化
    }
}
public class Test2 {
    public static void main(String[] args) {
        D d = new D();
    }
}
  • 构造 D 对象的同时, 会调用 B 的构造方法.
  • B 的构造方法中调用了 func 方法, 此时会触发动态绑定, 会调用到 D 中的 func
  • 此时 D 对象自身还没有构造, 此时 num 处在未初始化的状态, 值为 0
  • 所以在构造函数内，尽量避免使用实例方法

总结:用尽量简单的方式使对象进入可工作状态", 尽量不要在构造器中调用方法(如果这个方法被子类重写, 就会触发动态绑定, 但是此时子类对象还没构造完成), 可能会出现一些隐藏的但是又极难发现的问题.

记得午睡.
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
java 三大特性--封装、继承和多态理解
04-02
NULL 博文链接：https://lingf.iteye.com/blog/1450831
Java系列——封装、继承、多态初了解
wct040923的博客
05-06 9373
封装（Encapsulation）是面向对象方法的重要原则，就是把对象的属性和操作（或服务）结合为一个独立的整体，并尽可能隐藏对象的内部实现细节。将类的某些信息隐藏在类的内部，不允许外部程序进行直接的访问调用。通过该类提供的方法来实现对隐藏信息的操作和访问。隐藏对象的信息。留出访问的对外接口。​ 举个比较通俗的例子，比如我们的USB接口。如果我们需要外设且只需要将设备接入USB接口中，而内部是如何工作的，对于使用者来说并不重要。而USB接口就是对外提供的访问接口。
Java面向对象高级：封装、继承和多态
weixin_51980361的博客
02-09 558
学习笔记 — 封装、继承、多态、抽象类和接口
Java基础—封装继承多态(详细)
weixin_51779902的博客
06-16 7327
面向对象三大特征 封装 继承 多态1.封装定义:就是把事物封装成类,将类的某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法来实现对隐藏信息的操作和访问。
Java之封装、继承和多态（超详细）
weixin_54542328的博客
10-21 360
在子类中，可以根据需要对从父类中继承来的方法进行方法重写。重写以后，当子类对象调用与父类的同名同参数的方法时，优先调用子类重写的方法。当子类调用属性和方法的时候，如果自己类里面有该属性和方法，肯定先调用自己的，如果自己类里面没有，就去父类（先直接父类/再间接父类）找，一直找到Object类为止。子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表；子类重写的方法的返回值类型不能大于父类被重写方法的返回值类型。
Java封装继承多态
SGLP521的博客
10-10 187
在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。 封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。 封装的优点 良好的封装能够减少耦合。 类内部的结构可以自由修改。 可以对成员变量进行更精确的控制。 隐藏信息，实现细节。 实现Java封装的步骤 修改属性的可见性来限制对属性的访问（一般限制为private），例如： public class Per
Java的封装、继承、多态
Li_789的博客
03-19 727
封装（Encapsulation）、继承（Inheritance）、多态（Polymorphism）是面向对象编程（OOP）中的三个重要概念，它们是实现代码重用、提高代码可维护性和扩展性的关键。● 封装是将对象的状态（属性）和行为（方法）封装在一起，以实现数据隐藏和保护对象的内部状态。● 封装可以通过访问修饰符（如 public、private、protected）来限制对对象内部状态的访问，从而确保数据的安全性和完整性。
封装、继承、多态详细讲解(Java)
a_的博客
01-06 2489
Java封装、继承、多态讲解
Java封装、继承与多态
taoziba的博客
12-12 164
（1）FontDialog继承Dialog，FontDialog叫做子类，派生类或者扩展类；案例：有FontDialog和ParaDialog两个类，在主界面类中，定义一个函数，可以将对话框在界面中居中。编写代码，实现单例模式（某个对象在系统使用的过程中，永远保持不多于1个），以Windows的任务管理器为例。-性质：只有public类才能被包外的类导入并访问，普通类只能在同一个包中被访问。（前提：被导入的类是public类）性质：父类引用调用被覆盖的成员时，调用的是子类对象中的成员。
【Java】封装、继承与多态
m0_50987960的博客
10-29 1968
封装、继承、多态与四种访问修饰符
Java基础(八)：封装、继承、多态性
从基础到源码解析的学习记录
03-26 1639
从类的定义来看，类是一类具有相同特性的事物的抽象描述。而实例变量和实例方法就是事物的特征，那么父类中声明的实例变量和实例方法代表子类事物也有这个特征。如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有空参的构造器，则。所以继承意味着子类的对象除了看子类的类模板还要看父类的类模板。问题：在创建子类对象的过程中，一定会调用父类中的构造器吗？一个引用类型变量可能指向(引用)多种不同类型的对象。特别说明：应该避免子类声明和父类重名的成员变量。问题：创建子类的对象时，内存中到底有几个对象？
JAVA继承、封装和多态性
guanglihuan的专栏
03-22 731
继承、封装和多态是Java面向对象编程的三个核心概念，它们共同提供了一种强大的方式来组织和管理代码。继承允许我们建立一个基于通用类的特定类层次结构，从而促进代码重用和扩展。封装通过隐藏对象的内部状态和行为细节，提供了一种减少系统复杂性和增加可维护性的方法。多态性让我们能够编写可以在运行时做出决定的通用代码，从而让程序设计更加灵活和易于扩展。掌握这些概念对于成为一个熟练的Java程序员至关重要。
Java 封装 继承 多态（深入理解）
2302_79806056的博客
03-08 3762
详细解析了面向对象编程（java）的三大特性：封装继承和多态（超详细）收藏精品，帮助加深理解
Java三大特性：封装，继承与多态
冷血之心的博客
11-28 6611
（尊重劳动成果，转载请注明出处：https://blog.csdn.net/qq_25827845/article/details/84592274冷血之心的博客） 目录 （一）封装 封装的定义 封装的好处 （二）继承 继承的概念 子类的特点 构造函数 覆盖/重写的概念 （三）多态 多态的概念 向上转型 向下转型 总结 结束语         面向对象的语言有三大特...
Java基础知识之封装+继承+多态详解
weixin_47851265的博客
11-15 7501
Java面向对象三大特性:封装，继承和多态详解
Java 面向对象基础篇【三大特性：封装、继承、多态】
最新发布
故屿γ
03-29 1021
面向对象三大特征是面向对象编程的核心，它们使得代码更加模块化、可重用性和可维护性更强 ···
java封装继承多态详解
qq_56444564的博客
03-04 860
类就是封装数据和操作这些数据代码的逻辑实体。在一个类的内部，某些属性和方法是私有的，不能被外界所访问。通过这种方式，对象对内部数据进行了不同级别的访问控制（public,protected,private），就避免了程序中的无关部分的意外改变或错误改变了对象的私有部分。提高了代码的复用，继承有这样一种能力，就是使用现有的类的所有功能，还可以在父类的基础上进行扩展功能（重写或者实现新的方法）。实现继承可以直接使用基类的属性和方法而无需额外编码，接口继承是指使用属性和方法的名称，但是基类必须提供实现的能力。
java中的封装，继承，多态
weixin_51426897的博客
03-21 1408
封装： 面向对象的三大特性：封装继承和多态。 封装的意义在于保护或者防止代码（数据）被我们无意中破坏。保护成员属性，不让类以外的程序直接访问和修改。 private私有，封装原则：隐藏对象属性和实现细节，仅对外公开访问方法，并且控制访问级别。封装对象的成员属性，提供一个可供操作的方法。当私有了一个属性以后，提供一个用于设置和获取的方法。 定义一个普通的Person1类，普通的成员属性。 class Person1 { String name; int age; } 将Person1..
Java 封装 继承
qq_63448085的博客
10-30 337
封装，继承
"Java面向对象编程: 封装继承多态总结与实践
继承多态是面向对象编程中比较容易忽略的知识点，通过父类的引用指向子类的对象实现动态绑定，即不同对象在调用同一个方法时会表现出不同的行为。 总之，面向对象编程是Java中非常重要的一个概念，掌握好Java的面向...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值