4_面向对象（上）（Java学习笔记）

最新推荐文章于 2024-05-18 16:42:38 发布

DZSpace

最新推荐文章于 2024-05-18 16:42:38 发布

阅读量85

点赞数

分类专栏：软件开发文章标签： java 编程语言封装

原文链接：https://www.bilibili.com/video/BV1Kb411W75N?from=search&seid=10388185317086324785

版权

软件开发专栏收录该内容

16 篇文章 0 订阅

订阅专栏

1. 类与对象

1.1 面向对象的学习的三条主线

1.Java类及类的成员：属性、方法、构造器；代码块、内部类
2.面向对象的三大特征：封装性、继承性、多态性、(抽象性)
3.其它关键字：this、super、static、final、abstract、interface、package、import等

1.2 面向对象与面向过程（理解）

1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。
2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
举例对比：人把大象装进冰箱。
1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。
① 把冰箱门打开
② 抬起大象，塞进冰箱
③把冰箱门关闭
2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
人{
打开(冰箱){
冰箱.开开();
}
抬起(大象){
大象.进入(冰箱);
}
关闭(冰箱){
冰箱.闭合();
}
}
冰箱{
开开(){}
闭合(){}
}
大象{
进入(冰箱){
}
}

1.3. 完成一个项目（或功能）的思路

在这里插入图片描述

1.4. 面向对象中两个重要的概念：

类：对一类事物的描述，是抽象的、概念上的定义
对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)
面向对象程序设计的重点是类的设计
设计类，就是设计类的成员。
二者的关系：
对象，是由类new出来的，派生出来的。

1.5.对象的创建与对象的内存解析

典型代码：
Person p1 = new Person();
Person p2 = new Person();
Person p3 = p1;//没有新创建一个对象，共用一个堆空间中的对象实体。
说明：
如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）
意味着：如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。

1.6. 匿名对象:我们创建的对象，没显式的赋给一个变量名。即为匿名对象

特点：匿名对象只能调用一次。
举例：
new Phone().sendEmail();
new Phone().playGame();
new Phone().price = 1999;
new Phone().showPrice();//0.0
应用场景：
PhoneMall mall = new PhoneMall();
//匿名对象的使用
mall.show(new Phone());
其中，
class PhoneMall{
public void show(Phone phone){
phone.sendEmail();
phone.playGame();
}
}

1.7. 理解"万事万物皆对象"

1.在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
Scanner,String等
文件：File
网络资源：URL
2.涉及到Java语言与前端Html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。

2. 类的结构之一：属性

类的设计中，两个重要结构之一：属性

对比：属性 vs 局部变量

1.相同点：
1.1 定义变量的格式：数据类型变量名 = 变量值
1.2 先声明，后使用
1.3 变量都其对应的作用域

2.不同点：
2.1 在类中声明的位置的不同
属性：直接定义在类的一对{}内
局部变量：声明在方法内、方法形参、代码块内、构造器形参、构造器内部的变量
2.2 关于权限修饰符的不同
属性：可以在声明属性时，指明其权限，使用权限修饰符。
常用的权限修饰符：private、public、缺省、protected —>封装性
目前，大家声明属性时，都使用缺省就可以了。
局部变量：不可以使用权限修饰符。
2.3 默认初始化值的情况：
属性：类的属性，根据其类型，都默认初始化值。
整型（byte、short、int、long：0）
浮点型（float、double：0.0）
字符型（char：0 （或’\u0000’））
布尔型（boolean：false）
引用数据类型（类、数组、接口：null）
局部变量：没默认初始化值。
意味着，我们在调用局部变量之前，一定要显式赋值。
特别地：形参在调用时，我们赋值即可。
2.4 在内存中加载的位置：
属性：加载到堆空间中（非static）
局部变量：加载到栈空间

3. 类的结构之二：方法

类的设计中，两个重要结构之二：方法
方法：描述类应该具的功能。
比如：Math类：sqrt()\random() …
Scanner类：nextXxx() …
Arrays类：sort() \ binarySearch() \ toString() \ equals() \ …
1.举例：
public void eat(){}
public void sleep(int hour){}
public String getName(){}
public String getNation(String nation){}
2. 方法的声明：权限修饰符返回值类型方法名(形参列表){
方法体
}
注意：static、final、abstract 来修饰的方法，后面再讲。
3. 说明：
3.1 关于权限修饰符：默认方法的权限修饰符先都使用public
Java规定的4种权限修饰符：private、public、缺省、protected -->封装性再细说
3.2 返回值类型：返回值 vs 没返回值
3.2.1 如果方法返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用
return关键字来返回指定类型的变量或常量：“return 数据”。
如果方法没返回值，则方法声明时，使用void来表示。通常，没返回值的方法中，就不需要
使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。
3.2.2 我们定义方法该不该返回值？
① 题目要求
② 凭经验：具体问题具体分析
3.3 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
3.4 形参列表：方法可以声明0个，1个，或多个形参。
3.4.1 格式：数据类型1 形参1,数据类型2 形参2,…
3.4.2 我们定义方法时，该不该定义形参？
① 题目要求
② 凭经验：具体问题具体分析
3.5 方法体：方法功能的体现。
4. 方法的使用中，可以调用当前类的属性或方法
特殊的：方法A中又调用了方法A:递归方法。
方法中，不可以定义方法。

4. 面向对象的特征一：封装性

4.1 为什么要引入封装性？

我们程序设计追求“高内聚，低耦合”。
高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
低耦合：仅对外暴露少量的方法用于使用。
隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

4.2 问题引入：

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

4.3封装性思想具体的代码体现：

体现一：将类的属性xxx私化(private),同时，提供公共的(public)方法来获取(getXxx)和设置(setXxx)此属性的值

private double radius;
public void setRadius(double radius){
	this.radius = radius;
}
public double getRadius(){
	return radius;
}

体现二：不对外暴露的私有的方法
体现三：单例模式（将构造器私有化）
体现四：如果不希望类在包外被调用，可以将类设置为缺省的。

4.4 Java规定的四种权限修饰符

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

4.5 权限修饰符可用来修饰的结构说明：

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

5. 类的结构之三：构造器

5.1 构造器（或构造方法）：Constructor

构造器的作用：

1.创建对象
2.初始化对象的信息

5.2 使用说明：

1.如果没显式的定义类的构造器的话，则系统默认提供一个空参的构造器
2.定义构造器的格式：权限修饰符类名(形参列表){}
3.一个类中定义的多个构造器，彼此构成重载
4.一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
5.一个类中，至少会有一个构造器。

5.3 举例：

//构造器
	public Person(){
		System.out.println("Person().....");
	}
	
	public Person(String n){
		name = n;
		
	}
	
	public Person(String n,int a){
		name = n;
		age = a;
	}

总结属性赋值的顺序

 * 总结：属性赋值的先后顺序
 * ① 默认初始化
 * ② 显式初始化
 * ③ 构造器中初始化
 * **********************
 * ④ 通过"对象.方法" 或 "对象.属性"的方式，赋值
 * 
 * 以上操作的先后顺序：① - ② - ③ - ④

JavaBean的概念：

所谓JavaBean，是指符合如下标准的Java类：
类是公共的
一个无参的公共的构造器
属性，且对应的get、set方法

6.this关键字

6.1 可以调用的结构：属性、方法；构造器

6.2 this调用属性、方法：

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

6.3 this调用构造器：

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

public class PersonTest {
	public static void main(String[] args) {
		
		Person p1 = new Person();
		
		p1.setAge(1);
		System.out.println(p1.getAge());
		
		p1.eat();
		
		System.out.println();
		
		Person p2 = new Person("Jerry",20);
		System.out.println(p2.getAge());
		
	}
}

class Person{
	
	private String name;
	private int age;
	
	
	public Person(){
		
//		this.eat();
		String info = "Person初始化时，需要考虑如下的1,2,3,4...(共40行代码)";
		System.out.println(info);
	}
	
	public Person(String name){
		this();
		this.name = name;
		
	}
	
	public Person(int age){
		this();
		this.age = age;
		
	}
	
	public Person(String name,int age){
		this(age);
		this.name = name;
		//this.age = age;
		//Person初始化时，需要考虑如下的1,2,3,4...(共40行代码)
	}
	
	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return this.name;
	}
	public void setAge(int age){
		this.age = age;
	}
	public int getAge(){
		return this.age;
	}
	
	public void eat(){
		System.out.println("人吃饭");
		this.study();
	}
	public void study(){
		System.out.println("人学习");
	}
	
}

7. 关键字package/import

7.1 package的使用

1.为了更好的实现项目中类的管理，提供包的概念
2.使用package声明类或接口所属的包，声明在源文件的首行
3.包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
4.每"."一次，就代表一层文件目录。

7.2 举例：

举例一：
某航运软件系统包括：一组域对象、GUI和reports子系统
在这里插入图片描述
举例二：MVC设计模式

7.3 JDK中的主要包介绍：

在这里插入图片描述

7.4 import的使用：

import:导入
1. 在源文件中显式的使用import结构导入指定包下的类、接口
2. 声明在包的声明和类的声明之间
3. 如果需要导入多个结构，则并列写出即可
4. 可以使用"xxx.*"的方式，表示可以导入xxx包下的所结构
5. 如果使用的类或接口是java.lang包下定义的，则可以省略import结构
6. 如果使用的类或接口是本包下定义的，则可以省略import结构
7. 如果在源文件中，使用了不同包下的同名的类，则必须至少一个类需要以全类名的方式显示。
8. 使用"xxx.*"方式表明可以调用xxx包下的所结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入
9. import static:导入指定类或接口中的静态结构:属性或方法。

DZSpace

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
4_面向对象（上）（Java学习笔记）

1. 类与对象1.1 面向对象的学习的三条主线1.Java类及类的成员：属性、方法、构造器；代码块、内部类2.面向对象的三大特征：封装性、继承性、多态性、(抽象性)3.其它关键字：this、super、static、final、abstract、interface、package、import等1.2 面向对象与面向过程（理解）1.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。2.面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。举例对比：人把大象装进冰箱。
复制链接

扫一扫