JAVA学习——Java中面向对象的三大特征

最新推荐文章于 2024-09-22 21:04:03 发布
最新推荐文章于 2024-09-22 21:04:03 发布
阅读量329 收藏 1
点赞数
分类专栏： Java初体验 文章标签： java 类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangyongbaba/article/details/107178604
版权

 

目录

一、封装性

二、继承性

2.1 继承中的注意事项

2.2 继承设计原则

2.3 继承使用详解

2.3.1 子类访问成员变量和方法

2.3.2 super关键字

2.3.3 this关键字

2.3.4 方法重写

三、多态性

3.1 接口

3.1.2  常量

3.1.2 抽象方法

3.1.3 默认方法

3.1.4 静态方法

3.1.5 私有方法

3.1.6 接口实现步骤

3.1.7 类和接口之间关系：

3.2 多态性

3.2.1 多态的优点：

3.2.2 多态存在的三个必要条件

3.2.3. Java中多态实现

3.2.4 多态的使用规则

3.2.5 向上转型和向下转型：

一、封装性

封装性在Java当中的体现：
1. 方法就是一种封装
2. 关键字private也是一种封装（私有化，类似于）

使用private方法的时候，被封装后的成员变量不能直接访问，需要定义一对Getter/Setter方法，（必须叫setXxx或者getXxx命名规则）。代码如下：

public class Person {
    String name;
    private int age;

    public void show() {
        System.out.println("姓名：" + name + "年龄：" + age);
    }

    // 这个成员方法，专门用于向age设置数据
    public void setAge(int num){
        if (num < 150 && num>0){
            age = num;
        }else {
            System.out.println("格式输入不对！");
        }
    }

    // 这个成员方法，专门用于获取age的数据
    public int getAge() {
        return age;
    }
}

当然，在本类中通过this关键字可以访问到本类私有化的成员变量，格式为this.成员变量（类似python中的self），当需要调用成员变量的时候，都推荐使用this.成员变量，可以将成员变量和方法变量区分开来。面向对象的思想包括高内聚低耦合，良好的封装能够减少程序的耦合度，保证属性的操作安全性。

二、继承性

继承的概念：多个类中存在相同的属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只需要继承那个类即可。

这个单独的类被称为父类，也可以叫做超类，基类等。从这个类继承的类可以称为子类。子类拥有父类的所有属性与方法，无需重新定义。并且可以直接使用非私有的父类成员，同时子类还可以定义自己的属性和方法。在继承中，可以有多个继承关系，“子类就是一个父类”。也就是说，子类可以被当作父类看待，子类有父类的特征。

在java中通过extends关键字让类与类之间产生继承关系。定义一个继承关系的类为：

首先创建父类：

定义父类的格式：（一个普通的类定义）

public class 父类名称{
    //...
}

然后创建子类继承父类：

定义子类的格式：

public class 子类名称 extends 父类名称{
    //...
}

2.1 继承中的注意事项

  1. Java只支持单继承，不支持多继承。即只能有一个父类。
  2. 子类可以被当作父类看待，子类有父类的特征
  3. 所有类均有父类，只有Object类没有父类。Object为最高类

2.2 继承设计原则

对于已经投入使用的类，尽量不要进行修改。推荐定义一个新的类，来重复利用其中共性内容，并且添加改动新内容。

2.3 继承使用详解

2.3.1 子类访问成员变量和方法

局部变量：直接写成员变量名
本类的成员变量：this.成员变量名
父类的成员变量名：super.成员变量名

父类：

public class Fu(){

    Stirng name;

    int age;


    public void printFu(){

        System.ou.println(“父类方法”)

    }

}

子类：

public class Zi extends Fu(){

    Stirng sex;

    int id;


    public void printZi(int num){ // num为局部变量

        this.id += num; // 调用本类的成员变量

        System.ou.println(this.id)

        System.ou.println(super.name) //调用父类的成员变量

    }

}

2.3.2 super关键字

继承关系中，父子类构造方法的调用特点：
1. 子类构造方法当中有一个默认隐含的“super()”调用，所以一定是先调用的父类构造，后执行的子类构造。
2. 子类构造可以通过super关键字来调用父类重载构造。
3. super的父类构造调用，必须是子类构造方法的第一个语句，不能一个子类构造调用多次super构造
总结：
子类必须调用父类构造方法，不写则赠送super();写了则用写的指定的super调用，super只能有一个，还必须是第一个。

父类：

public class Fu {
    private int num = 10;
    private String sex;

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

    public Fu(String sex) {
        this.sex = sex; // 把局部变量赋值给成员变量
        System.out.println ("我是" + sex);
    }

}

子类：

public class Zi extends Fu{
    int num = 20;

    public Zi(){
        super(); // 调用父类的无参构造方法
        System.out.println ("子类构造方法");
    }

    public Zi(String sex){
        super(sex); // 调用父类的有参构造方法

    }

2.3.3 this关键字

super 关键字用来访问父类内容，而this关键字用来访问本类内容。用法也有三种；
1. 在本类的成员方法中，访问本类的成员变量。
2. 在本类的成员方法中，访问本类的另一个成员方法。
3. 在本类的构造方法中，访问另一个构造方法（访问的本类独有的构造方法）。
在第3种用法当中要注意：
this(...)调用也必须是构造方法的第一个语句。

public class Zi extends Fu{
    int num = 20;

    public Zi(){
        super();
    }

    public Zi(int num){
        this();
    }

    public Zi(int num, int num2){
        this(1000);
    }
}

2.3.4 方法重写

1. 重写（override）
概念：发生在继承关系当中，方法的名称一样，参数列表也一样。
2. 重写和重载的区别
重写（override）：方法的名称一样，参数列表也一样。
重载（overload）：方法的名称一样，参数列表不一样。
3. 方法的覆盖重写特点：创建的是子类对象，则优先使用子类方法。

4. 方法覆盖重写的注意事项：
 1) 必须保证父子类之间方法的名称相同，参数列表也相同。
@override：写在方法前面，用来检测是不是有效的正确覆盖重写。
这个注解就算不写，只要满足要求，也是正确的方法覆盖重写。

2) 子类方法的返回值必须【小于等于】父类方法的返回值范围
小扩展提示：java.lang.Object类是所有类的公共最高父类（祖宗类），java.lang.String就是Object的子类。

3) 子类方法的权限必须【大于等于】父类方法的权限修饰符/
小扩展提示：public > protected > (default) > private
备注：(default)不是关键字default，而是什么都不写，留空

三、多态性

3.1 接口

在学习多态性之前，需要先了解什么是接口。

接口就是一种公共的规范标准，只要符合规范标准，就可以通用。接口是一种引用数据类型，最重要的内容就是其中的：抽象方法。

如何定义一个接口的格式：

public interface 接口名称 {
    // 接口名称
}

备注：换成了关键字interface之后，编译生成的字节码文件仍然是：.java --> .class

如果是java 7，那么接口中可以包含的内容有：

3.1.2  常量

 成员变量其实是常量，格式：

public static final 数据类型 常量名称 = 数据值；

注意：

  1. 常量必须进行赋值，而且一旦复制不能改变，因为使用了final关键字
  2. 常量名称完全大写，用下划线进行分隔。
  3. 接口当中的常量，可以省略public static final，注意：不写也照样是这样。
  4. 接口当中的常量，必须进行赋值，不能不赋值。
  5. 接口当中的常量的名称，使用完全大写的字母，用下划线进行分割

示例代码：

public interface MyInterfaceConstant {

    public static final int NUM_OF_MY_CLASS = 77;

}

3.1.2 抽象方法

示例代码：

public interface MyInterfaceAbstract {

    // 这是一个抽象方法
    public abstract void methodAbs1();

    // 这是一个抽象方法
    public  void methodAbs2();

}

如果是java 8，可以额外包含有：

3.1.3 默认方法

1. 格式：

public default 返回值类型 方法名称(参数列表) {
    方法体
}

2. 备注：接口当中的默认方法，可以解决接口升级的问题。

示例代码：

public interface MyInterfaceDefault {

    // 抽象方法
    public abstract void methodAbs1();

    // 添加一个默认方法
    public default void methodDefault(){
        System.out.println ("新添加的默认方法");
    }
}

实现类可以重写默认方法，也可以不重写，都可以调用默认方法

3.1.4 静态方法

1. 格式：

public static 返回值类型 方法名称(参数列表){
    方法体
}

3. 提示：就是将abstract或者default换成static即可，带上方法体

4. 注意事项：不能通过接口实现类的对象来调用接口当中的静态方法。

5. 正确用法：通过接口名称，直接调用其中的静态方法。

格式：接口名称.静态方法名(参数)

示例代码：

public interface MyInterfaceStatic {
    public static void methodStatic(){
        System.out.println ("接口静态方法！");
    }
}

如果是java 9，还可以额外包含有：

3.1.5 私有方法

1. 普通私有方法，解决多个默认方法之间重复代码问题

格式：

private 返回值类型 方法名称(参数列表){
    方法体
}

示例代码：

public interface MyInterfacePrivateDefault {

    public default void methodDefault1(){
        System.out.println ("默认方法1");
        methodCommon ();
    }

    public default void methodDefault2(){
        System.out.println ("默认方法2");
        methodCommon ();
    }

    private void methodCommon(){
        System.out.println ("AAA");
        System.out.println ("BBB");
        System.out.println ("CCC");
    }
}

2. 静态私有方法，解决多个静态方法之间重复代码问题

格式：

private static 返回值类型 方法名称(参数列表){
    方法体
}

示例代码：

public interface MyInterfacePrivateStatic {

    public static void methodStatic1(){
        System.out.println ("静态方法1");
        methodStaticCommon ();
    }

    public static void methodStatic2(){
        System.out.println ("静态方法2");
        methodStaticCommon ();
    }

    private static void methodStaticCommon(){
        System.out.println ("AAA");
        System.out.println ("BBB");
        System.out.println ("CCC");
    }
}

3.1.6 接口实现步骤

1. 接口不能直接使用，必须有一个“实现类”，来“实现”接口

格式：

public class 实现类名称 implements 接口名称 {
    // ...
}

2. 接口的实现类必须覆盖重写（实现接口中所有的抽象方法）。

实现：去掉abstract关键字，加上方法体大括号

3.创建实现类的对象，进行使用

注意事项：

如果实现类没有覆盖重写接口中的所有抽象方法，那么这个实现类自己就必须是抽象类

4. 使用接口的时候需要注意：

  • 接口是没有静态代码块和构造方法的；
  • 一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。

格式：

public class MyInterfaceImpl implements MyInterfaceA,MyInterfaceB {
    // 覆盖重写所有抽象方法
}
  • 如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
  • 如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
  • 如果实现类所实现的多个接口当中，存在重复的默认方法，那么实现类一定要对冲突的默认方法进行覆盖重写。
  • 一个类如果直接父类当中的方法，和接口当中的默认方法产生了冲突，优先使用父类当中的方法。
  •  

3.1.7 类和接口之间关系：

1. 类与类之间是单继承的，直接父类只有一个。

2. 类与接口是多实现的，一个类可以实现多个接口。

3. 接口与接口之间是多继承的。

 

注意事项：

1. 多个父接口当中的抽象方法如果重复，没有关系。

2. 多个父接口当中的默认方法如果重复，那么子接口必须进行默认方法的覆盖重写，【而且带着default关键字】

 

3.2 多态性

多态是同一个行为具有多个不同表现形式或形态的能力。多态就是同一个接口，使用不同的实例而执行不同操作，如图所示：

 

3.2.1 多态的优点：

1. 消除类型之间的耦合关系

2. 可替换性

3. 可扩充性

4. 接口性

5. 灵活性

6. 简化性

3.2.2 多态存在的三个必要条件

1. 继承

2. 重写

3. 父类引用指向子类对象

 

java中实现多态性：

extends和implements就是多态性的前提。

3.2.3. Java中多态实现

代码当中实现多态性，其实就是一句话：父类引用指向子类对象。

格式：

父类名称 对象名 = new 子类名称();

或者：

接口名称 对象名 = new 实现类名称();

已图中为例，示例代码如下：

首先定义一个电脑接口：

public interface Computer {

    void playGame(); // 定义玩游戏的抽象方法，public abstract可以省略不写
}

然后定义一个笔记本电脑的实现类：

public class Laptop implements Computer {
    @Override
    public void playGame() {
        System.out.println ("笔记本玩游戏方便");
    }

    public void myLaptop() {
        System.out.println ("笔记本携带方便");
    }
}

台式电脑的抽象方法：

public class Desktop implements Computer{

    @Override
    public void playGame() {
        System.out.println ("台式电脑玩游戏舒服");
    }

    public void myDesktop(){
        System.out.println ("台式携带太麻烦啦");
    }
}

3.2.4 多态的使用规则

在多态的代码当中，成员方法的访问规则是：

看new的是谁，就优先用谁，没有则向上找。

成员变量：编译看左边，运行还看左边

成员方法：编译看左边，运行看右边，在调用方法的时候，如果子类重写了父类的成员方法，

那么会优先使用子类重写的方法，但是不能直接调用子类中特有的方法。

总结：不能直接访问子类（实现类）里接口没有的成员变量或者方法。

3.2.5 向上转型和向下转型：

1. 对象的向上转型，其实就是多态写法：

    格式：

        父类名称 对象名 = new 子类名称();

    含义：

        右侧创建一个子类对象，把它当作父类来看待使用。

    注意事项：

        向上转型一定是安全的，没有问题的，正确的，但是也有一个弊端：

        对象一旦向上转型父类，那么就无法调用子类特有的内容。

 

2. 对象的向下转型，其实就是一个【还原的动作】

    格式：

        子类名称 对象名 = (子类名称)父类对象;

        含义：将父类对象，【还原】成为本来的子类对象

    注意事项：

        * 必须保证对象本来创建的时候，就是猫，才能向下转型成为猫

        * 如果对象创建的时候本来不是猫，现在非要向下转型成为猫，就会报错。

如何才知道一个父类引用的对象本来是什么子类？

格式：

对象名 instanceof 类名称

这将会得到一个boolean值结果，也就是判断前面的对象能不能当作后面类型的实例。

代码示例：

public class DemoMain {

    public static void main(String[] args) {
        // // 对象的向上转型，就是：父类引用指向子类对象
        Computer computer1 = new Laptop (); 
        computer1.playGame (); // 父子都有的方法，那么就会优先有子类重写过后的方法
        //computer1.myLaptop(); // 错误写法

        // 如果希望调用子类特有的方法，需要向下转型，进行“还原”
        // 判断以下父类引用Computer本来是不是Laptop
        if (computer1 instanceof Laptop) {
            Laptop laptop = (Laptop) computer1;
            laptop.myLaptop ();
        }

        givemeAComputer (computer1);
    }

    // 最好创建一个方法来判断，因为子类可能不止有一个
    public static void givemeAComputer(Computer computer) {
        if (computer instanceof Laptop) {
            Laptop laptop = (Laptop) computer;
            laptop.myLaptop ();
        }else if (computer instanceof Desktop) {
            Desktop desktop = (Desktop) computer;
            desktop.myDesktop();
        }
    }
}

 

　Yo
关注
专栏目录
Java面向对象的特性
博客记录学习轨迹，方便日后复习
11-21 3290
SCAU面向对象程序设计复习总结——关于Java语言面向对象特性的介绍
8.java学习第八章——面向对象.pdf
01-20
Java 学习第八章——面向对象 #### 面向过程与面向对象的区别 在讨论面向过程和面向对象之前，我们先明确几个概念。编程语言根据其编程范式可以分为多种类型，其中面向过程和面向对象是最常见的两种。 **面向...
Java面向对象特性
johnston678的专栏
05-27 1745
Java面向对象特性1.继承(Inheritance)继承是面向对象编程的核心机制之一，其作用是在已有类型基础之上进行扩充或改造，得到新的数据类型，以满足新的需要．语法格式如下：[]　class 　[extends]{[][][]}2.类之间的关系1)依赖关系(Dependency)：指一个类的方法中使用到了另一个类的对象，此时我们称前者依赖后者．("use
Java面向对象的特征
宋程铬的专栏
03-13 4260
一、面向对象的特征有哪些方面 　　1.抽象： 　　抽象就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象并不打算了解全部问题，而只是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一是过程抽象，二是数据抽象。 　　2.继承： 　　继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可以从现有的类中派生，
java面向对象三大特性
qq_45789558的博客
09-02 577
【代码】java面向对象三大特性。
java面向对象的三大特性
ZF_9420的博客
06-07 962
1.封装 封装是指将客观事物抽象成类，每个类对自身的数据和方法实行保护。类可以将自己的数据和方法只让可信的类和方法操作，对不可信的进行信息隐蔽。 2.继承 继承是一种联结类的层次模型，并且允许和鼓励类的重用，它提供了一种明确表述共性的方法。对象的一个新类可从现有的一个类派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类或子类，而原始类称为新类的基类或父类。派生类可以从基
利用Java进行疫情大数据分析——“Java面向对象程序设计”课程实践教学设计研究.pdf
06-27
利用Java进行疫情大数据分析——“Java面向对象程序设计”课程实践教学设计研究.pdf
Java基础——面向对象编程
05-06
Java基础——面向对象编程 面向对象编程（Object-Oriented Programming，OOP）是一种编程方法，它将现实世界中的对象抽象出来，并使用计算机模型来描述。面向对象编程的核心概念是类（class）和实例（instance）。...
跟我学Java面向对象程序设计技术及应用——Java中的面向对象技术(第1部分).pdf
05-31
总的来说，理解并熟练运用面向对象编程技术，特别是Java中的面向对象特性，对于成为一名优秀的Java程序员至关重要。这包括创建和理解类的定义，使用封装、继承和多态性来设计和实现高效、可扩展的代码。通过不断的...
java上机报告2——java的面向对象设计1
08-08
Java 面向对象设计实践报告 本报告详细介绍了 Java 面向对象设计的实践过程，包括实验目标、实验要求、实验步骤、实验结果和实验总结。 实验目标：掌握面向对象的编程方法；掌握 Java 的面向对象特性；掌握采用...
java面向对象特征
04-14
java语言越来越成为计算机语言的主流，在java中面向对象的特征
Java中面向对象三大特性------封装、继承、多态
qq_46235384的博客
02-10 403
封装 封装性：保护和易用 访问权限控制 private/ public 这两个关键字表示 "访问权限控制" 被 public 修饰的成员变量或者成员方法, 可以直接被类的调用者使用. 被 private 修饰的成员变量或者成员方法, 不能被类的调用者使用 private实现属性封装，private修饰的类中属性只要不在该类中，别的类就不能访问 class Person { private String name = "张三"; private int age = ..
Java面向对象的三大特性，封装、继承、多态
m0_70437378的博客
11-18 142
我们可以将这些属性和方法封装在一个对象中，使得外部程序不能直接访问Person对象的属性或方法，只能通过Person类提供的方法进行操作。这样，我们可以保护Person对象的状态信息不被外部程序修改，同时也可以简化编程，因为用户只需要知道Person类提供哪些方法，而不需要了解内部细节。Student类继承了Person类的属性和方法，同时还可以增加新的能力，如学号和成绩等。通过继承，我们可以重用Person类的代码，避免重复编写相同的代码，同时也使Student类和Person类之间形成了一种层次关系。
Java中面向对象的三大特性
Miracle.Zhao的博客
09-20 236
估计学过面向对象的伙伴，对面向对象的三种属性应该都知道这么个事，今天突然兴起，想总结一下，因为大学本科学的基本都还给老师了。 面向对象有三大属性： 封装、继承、和多态。 我们接下来一个一个记录：（参考前人博客） 封装：首先是抽象，把事物抽象成一个类，其次才是封装，将事物拥有的属性和动作隐藏起来，只保留特定的方法与外界联系，封装就是将属性私有化，提供公有的方法访问私有属性。
JAVA面向对象三大特征
a61233的博客
11-26 1229
总之，封装、继承和多态是面向对象编程的三大基本特征，它们使得程序更加模块化、可维护性和可重用性更高。
【Java笔记】第8章：面向对象的三大特性（封装、继承、多态）
2302_80269373的博客
05-21 1893
各位小伙伴大家好！上期小编给大家讲解了Java中的面向对象，接下来讲讲Java中面向对象的三大特性！Java中面向对象的三大特性是封装（Encapsulation）、继承（Inheritance）和多态（Polymorphism）。这些特性是Java编程语言中实现面向对象编程（OOP）的核心概念。封装（Encapsulation）封装是指将数据（属性）和操作数据的方法（行为）封装在一起，形成一个不可分割的整体。在Java中，封装通过访问修饰符（如publicprivateprotected和。
java自用笔记：java基础语法——面向对象的三大特征（封装、继承（权限修饰符、继承的特点、方法重写、子类构造器、this调用兄弟构造器）、多态（好处、多态类型转换））
最新发布
xxyxxxqqq的博客
09-22 336
类就是封装（合理暴露，合理隐藏）：eg：一辆封装好的汽车，有的器件会暴露，有的零件会隐藏，封装就是如何把一个对象合理暴露合理隐藏。合理隐藏：为了防止数据被随意获取以及更改（合法更改、不合法更改，eg：age= -18），需要对成员变量（姓名年龄等添加私有private标签（只能在本类中访问其他地方不能访问））。合理暴露：不完全封闭数据获取渠道，利用set、get方法来对数据进行访问和修改。
java面向对象的特征
Triosans的博客
11-01 225
java面向对象的第三个特征是多态,我们在生活中就有很多类似多态的例子,同为一种行为有很多种不同的表现形式就叫多态 1.java实现多态的前提 1.两者基于继承关系或实现关系的 2.子类或实现类必须对方法进行重写(没有重写的方法,不具有多态行为) 3.父类的引用子类的对象(接口的引用指向实现类的对象) 2.多态的对象转型 1.子类对对象转父类对象时,称为向上转型,这种转型是默认的,因此是自动转型 2.父类的引用转成子类对象,称为向下转型,向下转型就需要强转 ...
Java基础--------面向对象三大特征
热门推荐
詹煜彪9527
02-27 1万+
一. 封装 封装（Encapsulation）是面向对象的重要特征之一，它是由类来体现的，就是把对象的属性和方法结合成一个独立的整体，把过程和数据包围起来，并尽可能地将对象的内部实现细节进行隐藏，通过已经定义的接口来控制用户对类的修改和访问数据的程度，防止该类中的代码和数据被外部类所定义的代码随机访问。在Java中通过关键字 private 、protected 和 public 来实现封...
面向对象编程基础——Java学习笔记
"Java学习笔记是一份非常适合Java初学者的资料，主要讲解了Java的面向对象编程概念，强调了面向对象编程的优点和实践方法。笔记中涵盖了类、对象、属性和方法等基础知识，并讨论了对象的高内聚、低耦合原则以及复用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值