面向对象编程（上）

最新推荐文章于 2022-08-23 19:16:06 发布

weixin_47621995

最新推荐文章于 2022-08-23 19:16:06 发布

阅读量101

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/weixin_47621995/article/details/107444301

版权

java 专栏收录该内容

14 篇文章 1 订阅

订阅专栏

一、面向过程与面向对象

1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。
2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
3.完成一个项目（或功能）的思路：
在这里插入图片描述

举例对比：人把大象装进冰箱。

【例子】把大象装冰箱一共分几步？

①打开冰箱 ②把大象装进去（存储大象）③关闭冰箱

如何运用面向对象思想思考上述问题？

人{
推(冰箱){
冰箱.关闭()
}

指挥(动物){
动物.进入()
}

拉(冰箱){
冰箱.打开()
}
}

冰箱{
打开(){}
存储(){}
关闭(){}
}

大象{
进入(){}
}

小松鼠(){
进入(){}
}

面向对象更加注重前期的设计

①就是对类的设计

②设计类的成员：属性 & 方法

1、面向对象：将现实生活中一类事物的共性内容，进行提取，抽象成相应的 Java 类，使用 Java 类对其进行描述

现实生活中的事物：张三李四王五

共性内容：姓名性别年龄吃饭的功能睡觉的功能

//抽象的：描述的是现实生活中的“一类”事物
class Person{
    //属性
    String name = "张三";
    char gender;
    int age;
    
    //方法-行为
    public void eat(){
        int a = 10;
        System.out.println("吃饭");
    }
    
    public void sleep(){
        System.out.println("睡觉");
    }
}

2、类是抽象的，描述的是现实生活中的“一类”事物。若需要具体到某一个人，通过 new 关键字创建对象

class PersonTest{
    public static void main(String[] args){
        //创建 Person 的对象
        Person p = new Person();
        //设置属性值
        p.name = "张三";
        p.gender = '男';
        p.age = 18;
        
        //获取属性值
        String n = p.name;
        System.out.println(n + "," + p.gender + "," + p.age);
        
        p.eat();
        p.sleep();
        
        Person p2 = new Person();
    }
}

3、类和对象

类：抽象的，描述的现实生活中的一类事物。相当于汽车设计图

对象：是一个实实在在的个体。相当于一辆辆的汽车

在这里插入图片描述
4.理解"万事万物皆对象"
1.在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构

```
 >Scanner,String等
```
```
 >文件：File
```
```
 >网络资源：URL
```

2.涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。

二、对象的属性

属性：也叫成员变量，也叫实例变量

1、局部变量&成员变量的区别

①作用域不同

②内存中的位置不同

③成员变量有默认值，局部变量没有默认值（因此局部变量使用前必须赋值）

2、属性的默认值

基本数据类型：

byte short int —> 0

long —> 0L

float —> 0.0F

double —> 0.0D

char —> ‘\u0000’

boolean —> false

引用数据类型： —> null

类(class)

接口(interface)

数组([])

3、为属性赋初始值的方式

①默认值（缺省值）

②直接显示赋值

三、参数的值传递：引用数据类型

基本数据类型：
在这里插入图片描述

引用数据类型:当将引用数据类型作为参数，传递给方法，方法运行结束后，原属性值会发生改变

class ReviewTest {
	public static void main(String[] args) {
		ReviewTest rt = new ReviewTest();

		Number1 num = new Number1();
		num.a = 10;
		num.b = 20;

		rt.add(num);
		System.out.println("num.a=" + num.a + " num.b=" + num.b);//
	}
	public void add(Number1 num){//相当于：Number1 num = new Number1()
		num.a += 1;
		num.b += 2;
	}
}

class Number1{

	int a;
	int b;

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FFoT7qc6-1595137399131)(img/1590804540603.png)]

四、Java 内存管理和垃圾回收

内存管理：

分配：由 JVM 自动的为其分配内存空间

释放：由 JVM 自动的通过垃圾回收机制释放内存空间

垃圾回收机制（GC Garbage Collection）：将内存中的垃圾对象从内存中释放
GC是垃圾收集的意思（Gabage Collection）,内存处理是编程人员容易出现问题的地方，
忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，Java语言没有提供释放已分配内存的显示操作方法。

垃圾对象：不再被任何引用指向的对象

Person p = new Person(); //分配

p = null;

System.gc() : 通知垃圾回收机制可以释放内存，但是垃圾回收机制并不会立即的执行

通知并加快垃圾回收机制的运行。

五、面向对象的特性之一：封装性

1.为什么要引入封装性？
我们程序设计追求“高内聚，低耦合”。
高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：仅对外暴露少量的方法用于使用。

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。
通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

2.问题引入：
当我们创建一个类的对象以后，我们可以通过"对象.属性"的方式，对对象的属性进行赋值。这里，赋值操作要受到属性的数据类型和存储范围的制约。除此之外，没其他制约条件。但是，在实际问题中，我们往往需要给属性赋值加入额外的限制条件。这个条件就不能在属性声明时体现，我们只能通过方法进行限制条件的添加。（比如：setLegs()同时，我们需要避免用户再使用"对象.属性"的方式对属性进行赋值。则需要将属性声明为私有的(private).
–>此时，针对于属性就体现了封装性。

3.封装性思想具体的代码体现：
体现一：将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值
private double radius;
public void setRadius(double radius){
this.radius = radius;
}
public double getRadius(){
return radius;
}
体现二：不对外暴露的私有的方法
体现三：单例模式（将构造器私有化）
体现四：如果不希望类在包外被调用，可以将类设置为缺省的。

4.Java规定的四种权限修饰符
4.1 权限从小到大顺序为：private < 缺省 < protected < public
4.2 具体的修饰范围：
在这里插入图片描述

4.3 权限修饰符可用来修饰的结构说明：
4种权限都可以用来修饰类的内部结构：属性、方法、构造器、内部类
修饰类的话，只能使用：缺省、public

class AnimalTest{
    
    public static void main(String[] args){
        Animal ani1 = new Animal();
        ani1.name = "大象";
        //ani1.legs = -1000;
        
        ani1.setLegs(-1000);
        
        int l = ani1.getLegs();
    }
}

class Animal{
    private String name;
    private int legs; //描述腿的个数
    
    public void setName(String name){
        this.name = name;
    }
    
    public String getName(){
        return name;
    }
    
    //设置属性值
    public void setLegs(int legs){
        if(legs >= 0 && legs <= 4 && legs % 2 == 0){
            this.legs = legs;
        }
    }
    
    //获取属性值
    public int getLegs(){
        return legs;
    }
}

六、this 关键字

1.可以调用的结构：属性、方法；构造器
2.this调用属性、方法：
this理解为：当前对象或当前正在创建的对象

2.1 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。但是，

通常情况下，我们都择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式
的使用"this.变量"的方式，表明此变量是属性，而非形参。
2.2 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。

3.this调用构造器：
① 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器
② 构造器中不能通过"this(形参列表)“方式调用自己
③ 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)”
④ 规定："this(形参列表)“必须声明在当前构造器的首行
⑤ 构造器内部，最多只能声明一个"this(形参列表)”，用来调用其他的构造器

谁让拥有 this 关键字的方法运行了，谁就是当前对象

class AnimalTest{
    
    public static void main(String[] args){
        Animal ani1 = new Animal();
        ani1.name = "大象";
        //ani1.legs = -1000;
        ani1.setLegs(-1000);
        int l = ani1.getLegs();
        
        Animal ani2 = new Animal();
        ani2.setName("老虎");
        ani2.setLegs(4);
    }
    
}

class Animal{
    private String name;
    private int legs; //描述腿的个数
    
    public void setName(String name){
        this.name = name;//用于区分局部变量和成员变量
    }
    
    public String getName(){
        return name;
    }
    
    //设置属性值
    public void setLegs(int legs){
        if(legs >= 0 && legs <= 4 && legs % 2 == 0){
            this.legs = legs;
        }
    }
    
    //获取属性值
    public int getLegs(){
        return legs;
    }
    
    public void show(){
        this.setLegs("设置属性值");
    }
}

七、构造器的声明和使用

构造器，也叫构造方法，是类的成员之一。

类的成员：属性、方法、构造器、内部类、代码块。

1、构造器的格式

访问控制修饰符类名(参数列表){
//功能语句
}

2、构造器的作用

①创建对象
②为对象进行初始化（创建对象的同时具备的属性和功能行为）

3、构造器的注意

①构造器的名称必须与类名一致！

②**若一个类中没有显示提供任何构造器时，系统会提供一个默认的无参构造器

public Person(){}

③**若一个类中显示的提供了任何一个构造器，系统默认无参构造器将不再提供

④构造器只能调用一次，并且是在创建对象的时候

⑤构造器之间可以构成重载

4、构造器的重载

使用在同一个类中

①构造器的名称相同

②参数列表不同（参数的个数、参数的类型）

5、为属性赋初始值的方式

①默认值（缺省值）

②直接显示赋值

③构造器赋值

顺序：①②③

class ConstructorTest{
    
    public static void main(String[] args){
        Person p = new Person();
        //p.cry();
        
        Person p1 = new Person();
        //p1.cry();
        
        Person p2 = new Person("张三");
    }
    
}

class Person{

	private String name;
    private int age;
    
    //声明一个构造器
    public Person(){
        cry();
    }
    
    public Person(String name){
        //this(name, 18);构成递归构造器调用，需要避免该情况的发生
        this.name = name;
    }
    
    public Person(String name, int age){
        this(name);
        this.age = age;
    }
    
    public void setName(String name){
        this.name = name;
    }
    
    public String getName(){
        return name;
    }
    
    public void cry(){
        System.out.println("哭……");
    }
    
}

八、包的管理

包的作用：
①用于区分重命名
②用于控制访问权限
③用于划分项目结构层次，通常将功能相近的类划分到同一个包中

package：用于确定当前类的位置
①写在当前 .java 源文件中可执行代码的首行
②包的命名规范：所有字母都小写。（通常使用所在公司域名的倒置）
www.atguigu.com --> com.atguigu.项目名.模块名
③每个 “.” 代表一层目录

import ：用于确定需要引入类的位置
①写在 package 与 class 之间
②import 语句可以有多条，并排列出
③import com.atguigu.java.* : 代表导入 java 包中所有的类和接口。（不包括包）
④若在一个类中使用两个相同类名不同包名的两个类时
如：java.sql.Date java.util.Date
选择一个使用 import java.sql.Date 导包的方式
选择另外一个使用全限定类名（全类名）java.util.Date date = new java.util.Date();
⑤import static 静态导包，可以导入一个类中所有的静态成员。（可以省略类名.）

JDK中的主要包介绍：
在这里插入图片描述

weixin_47621995

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
面向对象编程（上）

一、面向过程与面向对象1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。3.完成一个项目（或功能）的思路：举例对比：人把大象装进冰箱。【例子】把大象装冰箱一共分几步？①打开冰箱 ②把大象装进去（存储大象）③关闭冰箱如何运用面向对象思想思考上述问题？人{ 推(冰箱){ 冰箱.关闭() } 指挥(动物){ 动物.进入() } 拉(冰箱){ 冰箱.打开() }}冰箱{
复制链接

扫一扫