面向对象三大特点（三大特征）

最新推荐文章于 2024-07-30 19:54:51 发布
最新推荐文章于 2024-07-30 19:54:51 发布
阅读量106 收藏
点赞数
文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_72629434/article/details/125752488
版权

一、封装

概念：把属性设为private，隐藏内部细节限制外部直接访问，提供公共的get和set方法间接访问，提升安全性。

get方法用于获取内部属性

set方法用于设置内部属性的值

二、面向对象三大特点（三大特征）

封装、继承、多态

三、继承

子类继承父类，所有非私有的属性和方法（不包含构造器和主方法）

Java只能单一继承，一个类只能有一个父类（可以通过多重继承来实现多继承）

（所有的类都直接或间接继承了Object，Object万类之祖）

动物继承案例1

Animal

/**
 * 动物类
 *  名字、吃的方法
 */
public abstract class Animal {
    private String name;

    /**
     * 不明确是什么动物？吃的东西也不明确
     */
    public abstract void eat();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Cat

/**
 * 猫类
 *  继承动物类的属性和行为
 */
public class Cat extends Animal{
    /**
     * 猫吃鱼
     */
    @Override
    public void eat() {
        System.out.println(super.getName()+"吃鱼");
    }
}

Dog

/**
 * 狗类
 *  共有属性和行为直接从动物类继承
 */
public class Dog extends Animal{

    /**
     * 重写了父类的方法
     *  由于父类方法不满足使用，根据子类的特性进行重写
     */
    @Override
    public void eat() {
        System.out.println(super.getName()+"啃骨头");
    }
}

测试类

/**
 * 继承
 *  Aniaml
 *      子类：Dog Cat
 */
public class Test {
    public static void main(String[] args) {
        //创建Dog类对象
        Dog dog = new Dog();
        dog.setName("旺财");
        dog.eat();

        //创建猫类对象
        Cat cat = new Cat();
        cat.setName("花花");
        cat.eat();
    }
}

接口：为了弥补类只能单一继承的缺陷，后来演变为一种接口规范

​ 拍摄接口 打电话接口

​ 数码相机 拍照手机 固定电话

给动物都添加一个功能：跳高 Jump()

​ 定义一个Jump接口，所有需要的这个功能的，都实现这个接口

/**
 * 接口
 *  接口内只能有静态常量
 *      public static final 默认修饰符
 *  接口内的方法都是抽象方法
 *      public abstract 默认修饰符
 */
public interface Jump {

    void jump();
}

/**
 * 猫类
 *  继承动物类的属性和行为
 */
public class Cat extends Animal implements Jump{
    /**
     * 猫吃鱼
     */
    @Override
    public void eat() {
        System.out.println(super.getName()+"吃鱼");
    }

    @Override
    public void jump() {
        System.out.println(super.getName()+"像猫跳一样在跳高！！！");
    }
}

/**
 * 狗类
 *  共有属性和行为直接从动物类继承
 */
public class Dog extends Animal implements Jump{
    /**
     * 重写了父类的方法
     *  由于父类方法不满足使用，根据子类的特性进行重写
     */
    @Override
    public void eat() {
        System.out.println(super.getName()+"啃骨头");
    }

    @Override
    public void jump() {
        System.out.println(super.getName()+"像狗跳一样在跳高！！！");
    }
}

/**
 * 继承
 *  Aniaml
 *      子类：Dog Cat
 */
public class Test {
    public static void main(String[] args) {
        //创建Dog类对象
        Dog dog = new Dog();
        dog.setName("旺财");
        dog.eat();
        dog.jump();

        //创建猫类对象
        Cat cat = new Cat();
        cat.setName("花花");
        cat.eat();
        cat.jump();

    }
}

多态的案例

​ 概念：

​ 多态=多种形态=多种类型

​ 水：固态类型、液态类型、气态类型

​ 人的身份：学生类型、警察类型、医生类型、狗

​ 汽车人：汽车、机器人

​

​ Dog继承了Animal，这个dog对象，我们可以说你是Dog，也可以说你是Animal

​ 然后dog就拥有多种类型=多种形态=多态

​ 狗：狗类型、动物类型、生物类型

​ 先继承，才有多态

什么是多态的使用？

​ 把不同的子类对象都当作共同的父类来看，屏蔽了子类之间直接的差异

​ 可以设计通用的编程，大大提高代码的重用性

饲养员案例描述多态的使用：

​ 饲养员喂狗和猫，有什么共性：

内部类：类中定义类，web中用的不多，主要是JavaGUI中使用较多，感兴趣自行了解

四、异常

异常是程序编译或运行时发生的意外情况

Exception 编译期异常，编译期必须处理

RuntimeException 运行时异常，不必须处理，可以通过调整代码来避免

Error 错误，内存溢出等都是错误，不能解决

异常的解决：

​ throws抛出异常，不解决，一旦发生程序会崩溃

​ try-catch捕获异常，解决异常，程序继续运行

/**
 * 测试编译期异常
 */
public class Demo01 {
    public static void main(String[] args)  {

        //日期格式化类对象
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日");

        Date date = new Date();
        String s = sdf.format(date);//按照指定格式来格式化日期对象
        System.out.println("s = " + s);
        
        //解析字符串时，会抛出编译期异常：PaserException
        try {//try块放的是可能会发生异常的代码
            System.out.println(1);
            Date date2 = sdf.parse("2022年07月12日");//抛出了异常？编译期异常
            System.out.println(2);
            System.out.println("date2 = " + date2);
        } catch (ParseException e) {//一旦发生异常被catch语句捕获
            System.out.println(3);
            //e.printStackTrace();
        } finally {//无论try语句是否发生异常，都会执行
            System.out.println(4);
        }
        System.out.println(5);
        System.out.println("-->程序执行结束..");
    }
}

运行时异常

String s1 = "";
System.out.println(s1.charAt(0));//运行时异常：StringIndexOutofBoundsException

自定义异常（1.继承Exception的编译期异常 2.继承RuntimeException的运行时异常）

/**
 * 测试ATM取款
 */
public class Test {
    public static void main(String[] args) {
        //创建取款机
        ATM atm = new ATM();

        //创建银行卡
        BankCard bankCard = new BankCard();
        bankCard.setBalance(5000);//设置卡内余额

        //模拟ATM取款
        atm.setBankCard(bankCard);//插卡
        try {
            atm.withdrawMoney();//取款功能
        } catch (BalanceNotEnoughException e) {
            e.printStackTrace();
        }
        System.out.println("-->程序运行结束");
    }
}
/**
 * 银行卡
 *  余额
 */
class BankCard{
    private double balance; //余额
    public double getBalance() {
        return balance;
    }
    public void setBalance(double balance) {
        this.balance = balance;
    }
}
/**
 * ATM机
 *  插卡
 *  取款
 */
class ATM{
    private BankCard bankCard; //ATM机卡槽

    /**
     * 取款的方法
     */
    public void withdrawMoney() throws BalanceNotEnoughException {
        System.out.println("--请输入取款金额：");
        int money = new Scanner(System.in).nextInt();
        //判断卡余额是否足够
        if(money<=this.bankCard.getBalance()){
            System.out.println("-->提示：取款成功！！");
            this.bankCard.setBalance(this.bankCard.getBalance()-money);
            System.out.println("-->提示：取款"+money+"元，卡内余额："+this.bankCard.getBalance());
        }else{
            //抛出一个余额不足异常
            //System.out.println("-->警告：余额不足");
            throw new BalanceNotEnoughException();
        }
    }

    public BankCard getBankCard() {
        return bankCard;
    }
    //当作插卡
    public void setBankCard(BankCard bankCard) {
        this.bankCard = bankCard;
    }
}

--请输入取款金额：
5001
cn.hp.demo04.BalanceNotEnoughException: 警告！！账号余额不足！！
	at cn.hp.demo04.ATM.withdrawMoney(Test.java:64)
	at cn.hp.demo04.Test.main(Test.java:22)
-->程序运行结束

五、常用类库

java.lang包包含了常用类，系统做了设置无需导包即可使用

1、Object

万类之祖：所有的类都间接或直接的继承了Object类

equals()方法

​ String类继承并重写了Object的equals

​ == 可以比较基本数据类型的值是否相同，比较引用数据类型的对象是否是同一个

public class Demo01 {
    public static void main(String[] args) {
        String s1 = new String("abc");
        String s2 = new String("abc");
        System.out.println(s1.equals(s2));//true
        System.out.println(s1==s2);//false

        Cat c1 = new Cat("小白");
        Cat c2 = new Cat("小黑");
        System.out.println(c1==c2);//false
        System.out.println(c1.equals(c2));//true 重写过的equals方法
        Cat c3 = c1;
        System.out.println(c1==c3);//true
    }
}

/**
 * 猫类
 */
class Cat{
    private String name; //名字

    /**
     * 改写猫类对象的比较规则，重写Object类equals方法
     *  只要猫的名字一样就为真
     * @param o
     * @return
     */
    public boolean equals(Object o) {
        Cat c = (Cat) o;//向下转型
        //比较猫的名字
        return this.name.equals(c.name);
    }
    /*
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Cat cat = (Cat) o;
        return Objects.equals(name, cat.name);
    }
    */

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }

    public Cat() {
    }
    public Cat(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

hashCode()方法

​ 获取对象在堆内存的地址位置叫哈希码

toString()方法

​ toString方法默认拼接的对象首地址的@符号后的16进制数字就是hashCoe()哈希码

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

重写toString就可以改写打印输出对象的内容

toString()不写，默认就调用

//Dog类
class Dog{
    private String name;
    public Dog() {
    }
    public Dog(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return name;
    }
}

2、String

是字符串常量，一旦创建不可改变

//源码
public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence {
    /** The value is used for character storage. */
    private final char value[];

被final修饰，String类不能被继承

字符串值本质存在private final char value[];

用法和使用：参考JDK1.8API中文文档

3、可变字符串

String：字符串常量，一旦创建不可改变，线程不安全

StringBuffer：可变字符串，创建仍然可以改变，线程安全（数据在多个线程中同步）

StringBuilder：可变字符串，创建仍然可以改变，线程不安全（数据在多个线程中不同步）

用法和使用：参考JDK1.8API中文文档

4、包装类

包装类是为了将八种基本数据类型转为引用类型的形态

基本 包装类

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

基本数据可以和包装类自动转换：

​ 装箱（基本数据->包装类对象）和拆箱（包装类对象->基本数据）

weixin_72629434
关注
面向对象的三个重要特征。
qq_43658155的博客
03-07 467
前言 前文提到，面向对象的三个特征：封装、继承、多态。那么面向对象是怎么体现这三个特征呢？ 关于五大基本原则，个人找资料的时候看得头都大了，对新手（如我）来说还是比较有理解难度的，本篇用较为简单的表述来帮助理解。 面向对象的三大基本特征 1. 封装 封装，就是将客观事物抽象为逻辑实体，实体的属性和功能相结合，形成一个有机的整体。并对实体的属性和功能实现进行访问控制，向信任的实体开放，对不信任的实体...
面向对象的三大特征
热门推荐
Demon_and_Angle_的博客
07-25 1万+
面向对象的三大特征——封装、继承、多态
面向对象三大特点
weixin_69984559的博客
07-12 435
一、封装概念：把属性设为private，隐藏内部细节限制外部直接访问，提供公共的get和set方法间接访问，提升安全性。get方法用于获取内部属性set方法用于设置内部属性的值三、继承子类继承父类，所有非私有的属性和方法（不包含构造器和主方法）Java只能单一继承，一个类只能有一个父类（可以通过多重继承来实现多继承）（所有的类都直接或间接继承了Object，Object万类之祖）**动物继承案例1**Animal /** * 动物类 * 名字、吃的方法 */ public abstract clas
面向对象三大特征
ablikim0039的博客
05-26 123
面向对象三大特征：封装、继承、多态 继承是多态的前提，如果没有继承，就没有多态。 封装性在Java当中的体现： 方法就是一种封装 关键字private也是一种封装（一旦使用了private进行修饰，那么本类当中仍然可以随意访问。但是！！！超出了本类范围之外就不能再直接访问了。那么间接访问，就是通过一对getter/setter方法来设置或者获取成员变量，以及可以在setter方法对...
面向对象的三大特征（封装、继承、多态）
Alex十年的博客
01-13 3406
Java面向对象的体现是所有的声明必须放在一个类中，不允许在外面放东西。 面向对象设计的方法：根据现实问题直接抽象出对象，分析对象的行为和行为相关的数据，对象间通过传递消息进行通讯，从问题出发，模拟现实问题，建立系统模型，易于理解和实现。 结构化开发方法就是面向过程的方法： 1、采用自顶向下，逐步求精的程序设计方法 2、使用三种基本控制结构构造程序，任何程序都可以由顺序选择循环三种...
面向对象三大特征.xmind
08-17
java面向对象的精髓在于考虑问题的思路是从现实世界的人类思维习惯出发的,只要领会了这一点,就领会了面向对象的思维方法。这里有面向对象三大特征的思维导图帮你清楚的理解java面向对象。
PHP面向对象三大特点学习(充分理解抽象、封装、继承、多态)
10-28
本知识点将详细介绍PHP面向对象编程中的三大特点：抽象、封装和继承。 首先，我们来理解抽象的概念。抽象是指从具体的实例中抽取共同的特征和行为，形成一个通用的模板或类。在面向对象编程中，类就是一个抽象，它...
Python面向对象的三大特征
__Samual的博客
07-05 3622
目录一、封装1、私有变量2、私有方法 3、使用属性二、继承2.1单继承：2.2多继承 2.4方法的重写三、多态3.1 继承与多态3.2 鸭子类型测试与多态 封装性是面向对象重要的基本特性之一。封装隐藏了对象的内部细节，只保留有限的对外接口，外部调用者不用关心对象的内部细节，使得操作对象变得简单。 例如：一台计算机内部及其复杂，有主板，CPU，硬盘，内存等，而一般人不需要了解它的内部细节。计算机制造商用机箱把计算机封装起来，对外提供了一些接口，如鼠标，键盘，和显示器等，使用计
面向对象的三大特性
01-30
面向对象的三大特性 java基础核心技术
(三)面向对象的三大特征
lhd992692552的博客
08-21 518
JAVA中面向对象的三大特征： 面向对象具有继承性（Inheritance） 面向对象具有多态性（Polymorphism） 面向对象具有封装性（Encapsulation） 一、继承 多个类具有共同的属性（成员变量）与行为（成员方法）的时候，将这些共同的部分抽取出来定义到一个公共的类中，其他及各类可以与这个公共的类形成继承关系，从而在多个类中不需要重...
面向对象——三大特征
weixin_53049984的博客
07-21 139
一.封装 1、概念： 　 把客观事物封装成抽象的类，并且把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。也 就 是 说抽象数据类型对数据信息以及对数据的操作进行打包，将其变成一个不可分割 的实体，在这个实体内部，我们对数据进行隐藏和保密，只留下一些接口供外部调用。简单的说，一个类就是一个封装了数据以及操作这些数据的代码的逻辑实体。在一个对象内部，某些代码或某些数据可以是私有的，不能被外界访问。通过这种方式，对象对内部数据提供了不同级别的保护，以防止程序中无关的部分意外的改变或错误的使
java5-面向对象的三大特征
最新发布
zhaogodzero的博客
07-30 991
设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的代码设计的经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。
面向对象的三大特征，并解释其特点
07-20
面向对象编程（OOP）有三个主要特征：封装、继承和多态。 1. 封装（Encapsulation）：封装是将数据和方法封装在一个单元内部，对外部隐藏其内部实现细节的机制。通过将相关的数据和方法组织在一起，可以提高代码的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值