Java面向对象(三):封装,继承与多态

最新推荐文章于 2024-03-19 09:16:23 发布
最新推荐文章于 2024-03-19 09:16:23 发布
阅读量310 收藏
点赞数
分类专栏： Java基础 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42865964/article/details/127616504
版权

面向对象三大特征:封装,继承,多态

1.封装 ->封装的核心思想是权限控制,目的是信息保护
当类和类内部的成员被定义好后,基于安全性考虑可能并不希望把所有成员都暴露给外部调用,于是通过权限修饰符控制使得外部无法直接使用部分成员,这个过程就是封装。
public class Oop {

    //私有属性,仅当前类可以使用
    private int iPR = 0;

    //setter方法
    public void setiPR(int iPR){
        //赋值之前可以对入参进行控制
        if(iPR>10) iPR=add(iPR);
        
        this.iPR=iPR;
    };

    //getter方法
    public int getiPR(){
        return iPR;
    }
    
    //私有方法,仅当前类可以使用
    private int add(int i){
        return i+1;
    }
}
权限修饰符共有public,protected,默认,private四种。将在继承之后统一介绍
权限修饰符也可以修饰外部类,只能使用public和默认
public外部类:该外部类若想被包外的其他类中所访问,可以通过import关键字进行导包。
默认外部类:该外部类无法存在于包外的其他类中，即使导包也没用。

2.继承 ->继承的核心思想是分类(is-a),目的时代码复用
当定义的类越来越多后,为了便于管理要对定义的class进行分类。
同时,为了提高代码复用性,将同一类共同的代码抽出来让所有这一类的class都能使用。
共同使用的代码便重新定义一个class,就是父类。
而其余的class要使用extends关键字和这个公共class产生联系,就是继承。

public class Animal {
    //父类-动物
}

class Cat extends Animal{
    //子类-猫
}

class Dog extends Animal{
    //子类-狗
}

1).Java使用的是单继承,即一个类只能有一个父类,Java中所有类都继承自Object类。
2).final关键字可以修饰类,final修饰的类不可以被继承
3).由于Java的封装性,所以即使是继承关系也不能使用父类所有的成员
    四种权限修饰符
    private:私有的,本类使用
    defalut:默认的,可以省略不写。同包类使用。
    protected:受保护的,同包类+不同包子类使用
    public:公共的,项目中所有类

package com.springlight;

public class Animal {
    //private只能本类内使用
    private void m1(){

    };

    //默认
    void m2(){

    };;

    //受保护的
    protected void m3(){

    };;
    //公共的
    public void m4(){

    };;
}

class Cat extends Animal{

}

class Dog extends Animal{

}

class Bus{
    //同包类
    public void test(){
        Animal animal = new Animal();
        //private修饰的方法不可以使用
        //animal.m1();
        animal.m2();
        animal.m3();
        animal.m4();
    }
}

package com.springliant2;

import com.springlight.*;

public class Pig extends Animal {
    //不同包子类
    public void test(){
        Animal animal1 = new Animal();
        Pig pig = new Pig();
        //private修饰的方法不可以使用
        animal1.m1();
        pig.m1();
        //不同包时,默认修饰符修饰的的方法都不可用
        animal1.m2();
        pig.m2();

        //不同包时,protected修饰的方法,声明的父类对象不可用
        animal1.m3();
        //不同包时,protected修饰的方法,声明的子类对象可用
        pig.m3();

        //不同包时,public都可用
        animal1.m4();
        pig.m4();
    }
}

class Car {
    //不同包非子类
    public void test(){
        Animal animal1 = new Animal();
        Pig pig = new Pig();
        //private修饰的方法不可以使用
        animal1.m1();
        pig.m1();
        //不同包时,默认修饰符修饰的的方法都不可用
        animal1.m2();
        pig.m2();

        //不同包时,protected修饰的方法,声明的父类对象不可用
        animal1.m3();
        //不同包时,protected修饰的方法,声明的子类对象也不可用
        pig.m3();

        //不同包时,public都可用
        animal1.m4();
        pig.m4();
    }
}

4).继承具有传递性,子类本身也可以是其他类的父类。
5).方法重写:当子类继承父类的方法时,子类不想用父类的实现。可以对该方法重新定义
public class Animal {
    
    void m1(){
        System.out.println("父类方法m1");
    };
}

class Cat extends Animal{
    //通过Override注解表示这是个重写方法
    @Override
    void m1() {
        System.out.println("子类方法m1");
    }
}
6).私有方法不能被重写,final修饰的方法不能被重写

public class Animal {

    void m1(){
        System.out.println("父类方法m1");
    };
    
    final void m2(){
        System.out.println("父类方法m2");
    };
}

class Cat extends Animal{
    //这里@Override注解会报错。去掉注解不会报错,但相当于重写定义了新的方法
    @Override
    void m1() {
        System.out.println("子类方法m1");
    }
    
    //这里@Override注解会报错
    @Override
    void m2(){
        System.out.println("子类方法m2");
    };
    
}

7.重写方法的访问权限不能下降,权限访问大小排序为：private<默认<protected<public

public class Animal {
    void m2(){
        System.out.println("父类方法m2");
    };
}

class Cat extends Animal{
    
    //会报错
    @Override
    private void m2(){

    }
}

8).super关键字 -> 提示编译器引用父类的成员

public class Animal {
    
    void m1(){
        System.out.println("父类方法m1");
    };
}

class Cat extends Animal{
    //通过Override注解表示这是个重写方法
    @Override
    void m1() {
        System.out.println("父类方法m1");
    }
    
    void m2(){
        //调用自己的m1方法,也可以用this关键字
        m1();
        //通过父类对象调用父类的m1方法
        super.m1();
    }
}

9).有继承的情况下,创建对象时有以下几点
    内存一次性分配
    只生成一个对象,子类对象包着父类对象,先生成父类对象,再生成子类对象
    有多少父类就调用几次构造函数
    this指代当前对象,super并不指代父类对象。仅提示编译器指向父类的成员
    

10).子类对象创建时会首先创建父类对象并调用父类无参构造器,确保子类对象可以使用父类对象的成员

public class Animal {
    
    {
        System.out.println("父类构造代码块");
    }

    public Animal(){
        System.out.println("父类无参构造方法");
    }
    public Animal(int i){
        System.out.println("父类有参构造方法");
    } 
}

class Cat extends Animal{

    {
        System.out.println("子类构造代码块");
    }

    public Cat(){
        System.out.println("子类无参构造方法");
    }
    
    public Cat(int i){
        System.out.println("子类有参构造方法");
    }
}

public class Main {
    public static void main(String[] args) {
        Cat cat1 = new Cat();
        System.out.println("=======================");
        Cat cat2 = new Cat(1);
    }
}

上述Main方法执行结果为:
父类构造代码块
父类无参构造方法
子类构造代码块
子类无参构造方法
=======================
父类构造代码块
父类无参构造方法
子类构造代码块
子类有参构造方法

11).当父类没有无参构造方法时,子类会报错。必须在子类构造方法里手动调用父类构造方法,手动指定后将不在调用父类无参的构造方法
public class Animal {

    {
        System.out.println("父类构造代码块");
    }

    public Animal(int i){
        System.out.println("父类有参构造方法");
    } 
}

class Cat extends Animal{

    {
        System.out.println("子类构造代码块");
    }


    public Cat(){
        //会报错,必须使用super关键字手动调用父类构造方法,而且必须放在第一行
        super(1);
        System.out.println("子类无参构造方法");
    }
    
    public Cat(int i){
        //会报错,必须使用super关键字手动调用父类构造方法,而且必须放在第一行
        super(1);
        System.out.println("子类有参构造方法");
    }
}

public class Main {
    public static void main(String[] args) {
        Cat cat1 = new Cat();
        System.out.println("=======================");
        Cat cat2 = new Cat(1);
    }
}

执行结果:
父类构造代码块
父类有参构造方法
子类构造代码块
子类无参构造方法
=======================
父类构造代码块
父类有参构造方法
子类构造代码块
子类有参构造方法


12).创建子类对象的调用过程 ->加载父类,加载子类,创建父类对象,创建子类对象
public class Animal {

    static{
        System.out.println("父类静态代码块");
    }

    {
        System.out.println("父类构造代码块");
    }

    public Animal(){
        System.out.println("父类无参构造方法");
    }
}

class Cat extends Animal{

    static{
        System.out.println("子类静态代码块");
    }

    {
        System.out.println("子类构造代码块");
    }

    public Cat(){
        System.out.println("子类无参构造方法");
    }

    public Cat(int i){
        System.out.println("子类有参构造方法");
    }
}

public class Main {
    public static void main(String[] args) {
        Cat cat1 = new Cat();
        System.out.println("=======================");
        Cat cat2 = new Cat(1);
    }
}

执行结果:
父类静态代码块
子类静态代码块
父类构造代码块
父类无参构造方法
子类构造代码块
子类无参构造方法
=======================
父类构造代码块
父类无参构造方法
子类构造代码块
子类有参构造方法

13).虽然父类构造方法定义在子类构造方法第一行,但实际执行过程中,父类构造方法要先于于子类构造方法执行,甚至先于子类的构造代码块
public class Animal {
    //父类成员变量
    int i ;
    static{
        System.out.println("父类静态代码块");
    }

    {
        System.out.println("父类构造代码块");
        //通过构造代码块给父类对象成员变量赋值
        this.i=0;
        
    }

    public Animal(int i){
        System.out.println("父类有参构造方法");
        //输出此时的成员变量i
        System.out.println(this.i);
        //父类构造方法里再次赋值
        this.i = 1;
        
    }
}

class Cat extends Animal{

    static{
        System.out.println("子类静态代码块");
    }

    {    
        System.out.println("子类构造代码块");
        System.out.println(super.i);
        //子类构造代码块给父类对象的成员属性赋值
        super.i = 2;
        
    }

    public Cat(){
        super(1);
        System.out.println("子类无参构造方法");
        System.out.println(super.i);
    }

    public Cat(int i){
        super(1);
        System.out.println("子类有参构造方法");
        System.out.println(super.i);
    }
}

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

        Cat cat1 = new Cat();
        System.out.println("=======================");
        Cat cat2 = new Cat(1);
    }
}

执行结果
父类静态代码块 --加载父类class,执行父类静态代码块
子类静态代码块 --加载子类class,执行子类静态代码块
父类构造代码块 --创建父类对象,执行父类构造代码块,并给父类对象成员变量i赋值为0
父类有参构造方法 --执行父类有参构造方法
0 --输出父类成员变量i=0,将i赋值为1
子类构造代码块 --执行子类构造代码块
1 --输出此时的父类对象的成员变量i =1,并将i赋值为2
子类无参构造方法 --执行子类构造方法
2 --输出此时的父类对象的成员变量i = 2
=======================
父类构造代码块 --父类子类不必加载,此时创建父类对象,执行父类构造代码块,并给父类对象成员变量i赋值为0
父类有参构造方法 --执行父类有参构造方法
0 --输出父类成员变量i=0,将i赋值为1
子类构造代码块 --执行子类构造代码块
1 --输出此时的父类对象的成员变量i =1,并将i赋值为2
子类有参构造方法 --执行子类构造方法
2 --输出此时的父类对象的成员变量i = 2

3.多态 ->多态的核心思想是方法重写,目的是动态完成同一类对象的不同实现
public class Animal {
    public void m1(){
        System.out.println("Animal的m1");
    };
}

class Cat extends Animal{

    @Override
    public void m1(){
        System.out.println("Cat的m1");
    }
}

class Dog extends Animal{

    @Override
    public void m1(){
        System.out.println("Dog的m1");
    }
}

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

        Animal animal1 = new Animal();
        Animal animal2 = new Cat();
        Animal animal3 = new Dog();

        animal1.m1();
        animal2.m1();
        animal3.m1();
    }
}

运行结果为:
Animal的m1
Cat的m1
Dog的m1

1).里氏代换原则:任何基类出现的地方,使用派生类都不应该有问题
2).向上转型: 父类声明 = new 子类对象
   向下转型(需要强转)：子类声明 = (子类)new 父类对象

Springlighteve
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java面向对象三要素封装继承和多态源码
10-28
java面向对象三要素封装继承和多态源码java面向对象三要素封装继承和多态源码java面向对象三要素封装继承和多态源码java面向对象三要素封装继承和多态源码java面向对象三要素封装继承和多态源码java面向对象三要素...
Java面向对象-封装、继承、多态
longbin9409的专栏
08-13 436
--缺点：很难解决非常复杂的业务逻辑，且软件元素之间的“耦合度”非常高，只要其中一环出问题，整个系统都受到影响，导致最终的软件扩展力差。另外，无法达到组件复用。目前新出的语言都是面向对象的，因为人在认识现实世界的时候都是以面向对象的方式，这样更符合人的思维方式。---优点：对于业务逻辑比较简单的程序，可以达到快速开发，前期投入成本较低。注：C语言是纯面向过程、C++是半面向对象、Java是纯面向对象。面向对象：关注对象能完成哪些实际的功能。面向过程：关注具体的实现过程。......
Java面向对象-封装、继承和多态
忍冬的博客
05-27 2178
第一关 任务描述 本关任务：构造一个类，把对象的属性封装起来，同时提供一些可以被外界访问属性的方法。 相关知识 为了完成本关任务，你需要掌握： 1.什么是封装； 2.封装的意义； 3.实现Java封装的步骤。 什么是封装 封装：就是隐藏对象的属性和实现细节，仅对外提供公共访问方式。 封装时的权限控制符区别如下: 封装的意义 对于封装而言，一个对象它所封装的是自己的属性和方法，所以它是不需要依赖其他对象就可以完成自己的操作。使用封装有四大好处： 良好的封装能够减少耦合。 类内部的结构可以自由修改。 可以对
Java的封装、继承、多态
最新发布
Li_789的博客
03-19 543
封装（Encapsulation）、继承（Inheritance）、多态（Polymorphism）是面向对象编程（OOP）中的三个重要概念，它们是实现代码重用、提高代码可维护性和扩展性的关键。● 封装是将对象的状态（属性）和行为（方法）封装在一起，以实现数据隐藏和保护对象的内部状态。● 封装可以通过访问修饰符（如 public、private、protected）来限制对对象内部状态的访问，从而确保数据的安全性和完整性。
Java面向对象（封装、继承、多态···)
weixin_42843865的博客
07-11 172
面向对象的基本知识点
Java面向对象(封装,继承,多态)
fj123321666的博客
12-05 1190
本文介绍了面向对象的三大特征,封装,继承,多态,封装:讲述了set,get,属性设置过程的值如何传递,如何获取对象,附有实例讲解,提到了this关键字的使用,构造方法的使用,带参构造方法,无参构造方法,继承:讲述了继承的好处,不足,附有实例,多态:讲述了多态中成员访问特点,多态的向上转型和多态的向下转型,希望对大家的学习有所帮助
JAVA-面向对象-封装、继承和多态
Xingxinxinxin的博客
01-18 453
面向对象的特征封装、继承、多态（、抽象）封装将某些逻辑或者是代码提取成某种对应的形式，这个提取的过程就是封装封装包括：方法的封装、类的封装以及访问权限的封装。访问权限设置主要体现为---将属性设置为私有的，然后通过提供对外的方法来获取或者设置这个属性值，在方法中可以限制属性值使之更符合场景要求。封装的优点：提高代码的复用性，提高代码的安全性【因为属性私有化、方法公开化】权限修饰符   本类中
Educoder题目：Java面向对象 - 封装、继承和多态的综合练习答案解析.md
11-09
Educoder题目：Java面向对象 - 封装、继承和多态的综合练习答案解析
Java面向对象编程（封装/继承/多态）实例解析
08-29
主要介绍了Java面向对象编程（封装/继承/多态）实例解析的相关内容，具有一定参考价值，需要的朋友可以了解下。
Java开发中的三大特性：封装继承与多态的学习
06-11
面向对象有三大特性：封装继承与多态。通过简单易于理解的案例和概念，依次学习该三大特性。
JAVA面向对象的三大特征--封装、继承、多态
weixin_67224308的博客
11-14 2299
面向过程：就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。举例来说（办证）需要几步？按照面向过程思想：第一步：找到办事的人第二步：给办事的准备资料第三步 ：办完证，证件反馈给我这里我们就看出来，面向过程就是把一件事按步骤一步一步来实现代码表示依次调用这些方法就行对 Java 语言来说，一切皆是对象。把现实世界中的对象抽象地体现在编程世界中，一个对象代表了某个具体的操作。
Java面向对象三个特征--封装、继承及多态
我的博客
03-11 433
1、封装       1）为什么要封装？简单来说就是为了保证数据的安全性，以及隐藏复杂性（接口的具体实现），从而实现软件的灵活性、可维护性及可扩展性。     2）如何实现封装？隐藏实例变量，公开访问方法。         a）保护实例变量（使用private修饰符）。         b）创建公共的访问方法（比如getter()和setter()）。     3）IS-A指继承或...
java面向对象（封装-继承-多态）
weixin_30786617的博客
07-16 122
框架图 理解面向对象 面向对象是相对面向过程而言 面向对象和面向过程都是一种思想 面向过程强调的是功能行为 面向对象将功能封装进对象，强调具备了功能的对象。 面向对象是基于面向过程的。 面向对象的特点是一种符合人们思考习惯的思想可以将复杂的事情简单化将程序员从执行者转换成了指挥者完成需求时： 先要去找具有所需的功能的对象来用。 如果该对象不存在，那么创建一个...
Java面向对象|封装、继承和多态
Jasper的博客
10-19 885
目录一.什么是面向对象二.抽象(Abstract)三.封装(Encapsulation)1.封装的步骤2.作用和意义3.方法的重载四.继承1.继承的概述2.继承的格式3.extends关键字4.implements关键字5.super 与 this 关键字5.final关键字6.重写五.多态1.多态的概述2.多态存在的三个条件3.重写、重载和多态的关系4.无法表现多态特性的三种情况5.方法绑定6.instance of和类型转换六.接口和抽象类1.abstract修饰符2.接口和抽象类的区别3.接口的特征4
java中的面向对象（封装、继承和多态）
yogima的博客
08-29 679
一些基础 1.由于是面向对象的思想，在java中不再像cpp中一样，将其称之为成员函数和数据成员，相对应的叫法是对象的方法和属性。 2.java类中定义的属性叫成员变量，方法中定义的属性叫局部变量。   ①java会自动给成员变量赋一个初始值（一般为0）,但不会给局部变量赋初始值,编译时会提醒需要初始化。   ②局部变量和成员变量同名时，局部变量具有更高的优先级。 3.在java中创建对
Java面向对象：封装、继承、多态
王洋的专栏
09-30 4164
为什么要面向对象编程？ 以前开发的过程通常是采用面向过程编程，面向过程是以过程为中心来进行编程设计，本质上是分析出需要哪些过程，在编程时一步步的对其实现，但是随着软件规模的扩大，这种面向过程的设计模式已经越来越不适应如此大规模的软件。面向过程存在着诸多的缺点比如：     1.软件重用性差 重用性是指同一事物不经修改或稍加修改就可多次重复使用的性质。软件重用性是软件工程追求的目标之一。
Java面向对象三大特性(封装、继承、多态)
热门推荐
爱敲代码的三毛的博客
05-21 1万+
文章目录前言一、封装1.封装的概念2.private实现封装3.getter和setter方法4.封装的好处二、继承1.extends实现继承2.super 关键字三，多态总结 前言 OOP 语言：也就是面向对象编程。 面向对象的语言有三大特性：封装、继承、多态。三大特性是面向对象编程的核心。下面就来介绍一下面向对象的三大特性。 如果想了解面向对象可以看一下这一篇博客类和对象 一、封装 1.封装的概念 在我们写代码的时候经常会涉及两种角色: 类的实现者和类的调用者 封装的本质就是让类的调用者不必太多的.
super()与this()的主要区别
LvKuiSir的博客
04-24 623
不同点：1、super()主要是对父类构造函数的调用，this()是对重载构造函数的调用 2、super()主要是在继承了父类的子类的构造函数中使用，是在不同类中的使用；this()主要是在同一类的不同构造函数中的使用 相同点： 1、super()和this()都必须在构造函数的第一行进行调用，否则就是错误的...
java面向对象-封装、继承和多态头歌
11-02
综上所述，封装、继承和多态是Java面向对象编程中的重要概念。封装可以保证数据的安全性和完整性，继承可以实现代码的复用和功能的扩展，多态可以提高代码的灵活性和可扩展性。掌握这三个概念，可以帮助我们更好地...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值