JavaOOP 01 对象和封装

兰巧儿

已于 2023-02-16 11:05:43 修改

阅读量98

点赞数

分类专栏： JavaOOP 文章标签：软件工程

于 2023-02-10 17:02:43 首次发布

本文链接：https://blog.csdn.net/m0_72817617/article/details/128973734

版权

JavaOOP 专栏收录该内容

10 篇文章 1 订阅

订阅专栏

文章介绍了面向对象编程的核心概念，包括类、对象、封装、继承和多态。强调了面向对象在解决复杂问题和提高代码质量上的优势。接着，详细阐述了如何使用面向对象设计，包括分析需求、创建类和方法。接着，讨论了构造方法的作用和定义，以及this关键字的使用。此外，还解释了方法重载的概念和特点，以及它在简化代码和提高灵活性上的优点。

摘要由CSDN通过智能技术生成

一、对象和封装

1.1 面向对象设计

1.1.1 回顾面向对象

什么是面向对象

面向对象编程
面向对象编程的本质就是：以类的方式组织代码，以对象的组织(封装)数据
抽象：(把多个事物的共同点抽取出来，形成一个类)
三大特性
- 封装(把代码封装起来，由外部访问)
- 继承(由子类继承父类的方法和属性)
- 多态(同一种事物的不同的形态)
从认识论角度考虑先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
从代码允许角度，先有类后有对象。类是对象的模板

**面向过程 & 面向对象 **

面向过程思想
- 步骤清晰，第一步做什么，第二步做什么…
- 面对过程适合处理一些较为简单的问题
面向对象思想
- ；物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索
  - 面向对象适合处理复杂的问题，适合处理需要多人协作的问题

面向对象的好处

易维护、质量高、效率高、易扩展

1.1.2 使用面向对象设计

使用面向对象分析

第一步：分析需求，归纳出类
第二步：发现类的属性
第三步：发现类的方法
为了更清楚的表示类，可以将设计结果通过类图进行描述
- 类图是软件工程的统一建模语言，是一种静态结构图
- 类图以反映类的结构(属性、操作)及类之间的关系为目的
- 示例如下
  - 箭头指向的为父类
  - +表示public
  - -表示private
  - #表示protected

设计类时遵循的原则
- 属性和方法是为了解决业务问题设置的
- 关注主要属性和方法
- 如果没必要，那么不要增加额外的类、属性与方法

1.1.3 构造方法

构造方法的作用

当需要设置的属性很多时，可在创建对象时就完成赋值
通过构成方法完成对象的创建，以及实例变量的初始化
注意：实例变量没有手动赋值的时候，系统会赋默认值。

构造方法的定义

语法

访问修饰符方法名 (参数列表){

//代码块

}

没有参数的构造方法称之为无参构造，反之，称之为有参构造

注意事项

构造方法的名称必须和类名相同
没有返回值类型
构造方法的参数列表是可选的，可以定义无参构造和有参构造
一个类至少有一个无参构造，如果没有创建，系统会自动创建一个无参构造

示例

public class Main {
    //实例变量
    public String name;
    public int age;
    //使用无参构造赋值
    public Main(){
        //在构造方法中给实例变量赋值
        //this指当前类
        this.name="Java";
        this.age=28;
    }
    //使用有参构造赋值
    public Main(String name,int age){
        this.name=name;
        this.age=age;
    }
    //主方法
    public static void main(String[] args) {
        //在创建对象时，就会调用构造方法
        //此时，实例变量已被赋值
        //无参构造
        Main main1=new Main();
        System.out.println("我的名字是:"+main1.name);
        System.out.println("我今年"+main1.age+"岁啦");
        //有参构造
        Main main2=new Main("html",33);
        System.out.println("我的名字是:"+main2.name);
        System.out.println("我今年"+main2.age+"岁啦");
    }
}

注意: 如果无参和有参同时出现，创建方法时会根据参数类型及数量自行对应运行不同的构造方法

this关键字

对一个对象的默认引用
this指的时当前对象
表示当前对象的属性或方法

this关键字的三种用法

（1） this关键字调用成员变量，解决成员变量和局部变量的同名冲突

public class Test {
    //this关键字调用成员变量，解决成员变量和局部变量的同名冲突
    String brand;
    public void AppleTree(String brand){
        //this.brand指成员变量
        //brand指的是局部变量，也就是上方的参数
        this.brand=brand;
    }
}

（2）使用this关键字调用成员方法

public class Test {
    //使用this关键字调用成员方法
    //成员方法
    public void print(){
        System.out.println("Hello Word");
    }
    public void changeName(String name){
        //调用成员方法
        this.print();
    }
}

（3）使用this关键字调用已经定义的构造方法

构造方法只可以在构造方法中调用

this调用构造方法语法: this(实参)

public class Test {
    //使用this关键字调用已经定义的构造方法
    String name;
    String Sex;
    int age;
    String dept;
    public Test(String name,String Sex){
        this.name=name;
        this.Sex=Sex;
    }
    public Test(String name,String Sex,int age,String dept){
        //使用this调用构造方法
        this(name, Sex);
        this.age=age;
        this.dept=dept;
    }
}

1.1.4 方法重载

方法重载的定义

方法的重载是指一个类中可以定义有相同的名字，但参数不同的多个方法。调用时，会根据不同的参数表选择对应的方法。

方法重载的特点

必须在同一类
方法名相同
参数列表（方法参数的个数或参数类型不同）
跟返回值类型无关
只有返回值不同不构成方法重载。
只有形参的名称不同，不构成方法重载。
构造函数也可以重载

方法重载示例

public class Test05 {
    public void getSum(int a,int b){
        System.out.println("整数:"+(a+b));
    }
    public void getSum(double a,double b){
        System.out.println("小数:"+(a+b));
    }

    public static void main(String[] args) {
        Test05 test05=new Test05();
        test05.getSum(2,3);
        test05.getSum(7.5,1.5);
    }
}

方法重载的优点

可以根据参数的不同，采用不同的实现方法
不需要编写多个名称
简化了类调用方法的代码

1.2 使用封装重构类的属性和方法

1.2.1 封装的概念

对信息的保护

保护代码，防止外部的代码随意访问
尽量暴露少的方法给外部使用
可对数据设置一定的限制，防止被随意赋值
隐藏信息，实现细节

在Java中使用封装

使用关键字private设置属性为私有
- 设置private私有属性，在别的类就无法调用该方法
- 调用private属性应用get和set关键字
使用get关键字在别的类获取封装类的数据
使用set关键字在别的类修改或设置封装类的数据
大部分使用为属性使用封装，方法一般不使用

1.2.2 实现Java封装的步骤

Stundent对象类

public class Student {
    //私有属性
    private String name;  //姓名
    private int age; //年龄
    private char sex; //性别

    //提供public 的get 和 set方法 获取或设置值
    //获取name值
    public String getName(){
        return this.name;
    }
    //设置name值
    public void setName(String name){
        this.name=name;
    }
}

Main主方法，运行类

public class Application {
    public static void main(String[] args) {
        Student s1=new Student();
        //使用set方法给Student类的name值赋值
        s1.setName("兰巧儿");
        //使用get方法获取Student类的name值
        System.out.println(s1.getName());
    }
}

快捷生成get和set方法

使用快捷键Alt键+Ins键
选择要生成的get方法或set方法
选择要生成的属性

1.2.3 使用封装对数据赋值进行限制

Stundent对象类

一般年龄的输入要符合实际所有要进行限制

public class Student {
    //私有属性
    private String name;  //姓名
    private int age; //年龄
    private char sex; //性别

    //提供public 的get 和 set方法 获取或设置值
    //获取name值
    public int getAge() {
        return age;
    }
    //赋值时对年龄进行限制
    public void setAge(int age) {
        //如果年龄大于200岁并且小于0岁 那就默认年龄为18
        if (age>200||age<0){
            this.age = 18;
        }else {
            this.age=age;
        }
        
    }
}

Main主方法，运行类

public class Application {
    public static void main(String[] args) {
        //如果赋的年龄大于200岁
        Student s1=new Student();
        s1.setAge(230);
        System.out.println(s1.getAge());
        //如果赋的年龄为正常范围
        Student s2=new Student();
        s2.setAge(35);
        System.out.println(s2.getAge());
    }
}

Get和Set方法称之为属性封装

1.2.4 封装的主要步骤

1. 修改属性的可见性

2. 创建赋值(Set)和取值(Get)方法

3. 加入属性的存取控制语句

1.2.5 类和类成员的访问控制

1. 类的访问修饰符

修饰符	作用域
修饰符	同一包中	不同包中
public	可以使用	可以使用
default(默认修饰符)	可以使用	不可以使用

2. 类成员的访问修饰符

修饰符	作用域
修饰符	同一类中	同一包中	子类中	外部包
private	可以使用	不可以使用	不可以使用	不可以使用
default(默认修饰符)	可以使用	可以使用	不可以使用	不可以使用
protected	可以使用	可以使用	可以使用	不可以使用
public	可以使用	可以使用	可以使用	可以使用