Java基础编程篇（4.面向对象上）
Posted 王六六的IT日常
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Java基础编程篇（4.面向对象上）相关的知识，希望对你有一定的参考价值。
前言
尚硅谷 - Java课程 - 笔记（用于自己复习）
终于把面向对象看完了🤣，总结一下，基础篇就结束啦~
一、类与对象
1.面向对象学习的三条主线
-
Java类及类的成员：属性、方法、构造器；代码块、内部类
-
面向对象的三大特征：封装性、继承性、多态性、(抽象性)
-
其它关键字：this、super、static、final、abstract、interface、package、import等
“大处着眼，小处着手”
2.面向对象与面向过程（理解）
- 面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。
- 面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
举例对比：人把大象装进冰箱。
3.完成一个项目（或功能）的思路
4.面向对象中两个重要的概念
- 类：对一类事物的描述，是抽象的、概念上的定义
- 对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)
- 面向对象程序设计的重点是类的设计
- 设计类，就是设计类的成员。
二者的关系：
对象，是由类new出来的，派生出来的。
5.面向对象思想落地实现的规则一
- 创建类，设计类的成员
- 创建类的对象
- 通过“对象.属性”或“对象.方法”调用对象的结构
补充：几个概念的使用说明
- 属性 = 成员变量 = field = 域、字段
- 方法 = 成员方法 = 函数 = method
- 创建类的对象 = 类的实例化 = 实例化类
6.对象的创建与对象的内存解析
典型代码：
Person p1 = new Person();
Person p2 = new Person();
Person p3 = p1;//没有新创建一个对象，共用一个堆空间中的对象实体。
说明：
如果创建了一个类的多个对象，则每个对象都独立的拥有一套类的属性。（非static的）
意味着： 如果我们修改一个对象的属性a，则不影响另外一个对象属性a的值。
内存解析：
7.匿名对象
我们创建的对象，没显式的赋给一个变量名。即为匿名对象
特点： 匿名对象只能调用一次。
举例：
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();
}
}
8.理解"万事万物皆对象"
- 在Java语言范畴中，我们都将功能、结构等封装到类中，通过类的实例化，来调用具体的功能结构
- Scanner,String等
- 文件：File
- 网络资源：URL
- 涉及到Java语言与前端html、后端的数据库交互时，前后端的结构在Java层面交互时，都体现为类、对象。
JVM内存结构
编译完源程序以后，生成一个或多个字节码文件。
我们使用JVM中的类的加载器和解释器对生成的字节码文件进行解释运行。意味着，需要将字节码文件对应的类加载到内存中，涉及到内存解析。
《JVM规范》
虚拟机栈，即为平时提到的栈结构。我们将局部变量存储在栈结构中
堆，我们将new出来的结构（比如：数组、对象）加载在堆空间中。
补充： 对象的属性（非static的）加载在堆空间中。
方法区： 类的加载信息、常量池、静态域
二、类的结构之一：属性
类的设计中，两个重要结构之一：属性
对比： 属性 vs 局部变量
1.相同点：都是变量
- 定义变量的格式：数据类型 变量名 = 变量值;
- 先声明，后使用
- 变量都其对应的作用域
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）
局部变量：加载到栈空间
补充：回顾变量的分类：
方式一：按照数据类型：
方式二：按照在类中声明的位置：
三、类的结构之二：方法
类的设计中，两个重要结构之二：方法
方法：描述类应该具的功能。
比如：
- Math类：sqrt()\\random() …
- Scanner类：nextXxx() …
- Arrays类：sort() \\ binarySearch() \\ toString() \\ equals() \\ …
- 举例：
public void eat(){} //没形参、返回
public void sleep(int hour){} //有形参
public String getName(){} //有返回
public String getNation(String nation){}
- 方法的声明：
权限修饰符 返回值类型 方法名(形参列表){
方法体
}
注意：static、final、abstract 来修饰的方法，后面再讲。
3.说明
3.1 关于权限修饰符
默认方法的权限修饰符先都使用public
Java规定的4种权限修饰符：private、public、缺省、protected -->封装性再细说
3.2 返回值类型： 返回值 vs 没返回值
- 如果方法有返回值，则必须在方法声明时，指定返回值的类型。
同时，方法中，需要使用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 方法体：方法功能的体现。
3.方法的使用中，可以调用当前类的属性或方法
特殊的：方法A中又调用了方法A:递归方法。
方法中，不可以定义方法。
return关键字
1.使用范围：使用在方法体中
2.作用：
① 结束方法
② 针对于返回值类型的方法，使用"return 数据"方法返回所要的数据。
3.注意点：return关键字后面不可以声明执行语句。
4.返回值类型： 返回值 vs 没返回值
- 如果方法有返回值，则必须在方法声明时，指定返回值的类型。
同时，方法中，需要使用return关键字来返回指定类型的变量或常量：“return 数据”。 - 如果方法没返回值，则方法声明时，使用void来表示。
通常，没返回值的方法中，就不需要使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。
方法的重载
1.概念
定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
总结： “两同一不同”
- 同一个类、相同方法名
- 参数列表不同：参数个数不同，参数类型不同
2.举例
构成重载的举例：
举例一：
Arrays类中重载的sort() / binarySearch()；PrintStream中的println()
举例二：
//如下的4个方法构成了重载
public void getSum(int i,int j){
System.out.println("1");
}
public void getSum(double d1,double d2){
System.out.println("2");
}
public void getSum(String s ,int i){
System.out.println("3");
}
public void getSum(int i,String s){
System.out.println("4");
}
不构成重载的举例：
//如下的3个方法不能与上述4个方法构成重载
public int getSum(int i,int j){
return 0;
}
public void getSum(int m,int n){
}
private void getSum(int i,int j){
}
3.如何判断是否构成方法的重载？
- 严格按照定义判断：两同一不同。
- 跟方法的权限修饰符、返回值类型、形参变量名、方法体都没关系！
4.如何确定类中某一个方法的调用：
方法名 —> 参数列表
面试题：方法的重载与重写的区别？
throws\\throw
String\\StringBuffer\\StringBuilder
Collection\\Collections
final\\finally\\finalize …
抽象类、接口 有什么区别？
sleep() / wait()有什么区别？
可变个数形参的方法
1.使用说明：
- jdk 5.0新增的内容
- 具体使用：
- 可变个数形参的格式：数据类型 … 变量名
- 当调用可变个数形参的方法时，传入的参数个数可以是：0个，1个,2个，。。。
- 可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载
- 可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。换句话说，二者不能共存。
- 可变个数形参在方法的形参中，必须声明在末尾
- 可变个数形参在方法的形参中,最多只能声明一个可变形参。
2.举例说明：
public void show(int i){
}
public void show(String s){
System.out.println("show(String)");
}
public void show(String ... strs){
System.out.println("show(String ... strs)");
for(int i = 0;i < strs.length;i++){
System.out.println(strs[i]);
}
}
//不能与上一个方法同时存在
// public void show(String[] strs){
//
// }
调用时：
test.show("hello");
test.show("hello","world");
test.show();
test.show(new String[]{"AA","BB","CC"});
java的值传递机制
1.针对于方法内变量的赋值举例：
System.out.println("***********基本数据类型：****************");
int m = 10;
int n = m;
System.out.println("m = " + m + ", n = " + n);
n = 20;
System.out.println("m = " + m + ", n = " + n);
System.out.println("***********引用数据类型：****************");
Order o1 = new Order();
o1.orderId = 1001;
Order o2 = o1;//赋值以后，o1和o2的地址值相同，都指向了堆空间中同一个对象实体。
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
o2.orderId = 1002;
System.out.println("o1.orderId = " + o1.orderId + ",o2.orderId = " +o2.orderId);
规则：
如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
2.针对于方法的参数概念
形参：方法定义时，声明的小括号内的参数
实参：方法调用时，实际传递给形参的数据
3.java中参数传递机制：值传递机制
规则：
如果参数是基本数据类型，此时实参赋给形参的是，实参真实存储的数据值。
如果参数是引用数据类型，此时实参赋给形参的是，实参存储数据的地址值。
推广：
如果变量是=基本数据类型，此时赋值的是，变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是，变量所保存的数据的地址值。
4.典型例题与内存解析：
【例题1】参数类型为：基本数据类型
【例题2】参数类型为：引用数据类型
递归方法
1.定义
一个方法体内调用它自身。
2.如何理解递归方法？
- 方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。
- 递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。
3.举例：
// 例1：计算1-n之间所自然数的和
public int getSum(int n) {// 3
if (n == 1) {
return 1;
} else {
return n + getSum(n - 1);
}
}
// 例2：计算1-n之间所自然数的乘积:n!
public int getSum1(int n) {
if (n == 1) {
return 1;
} else {
return n * getSum1(n - 1);
}
}
//例3：已知一个数列：f(0) = 1,f(1) = 4,f(n+2)=2*f(n+1) + f(n),
//其中n是大于0的整数，求f(10)的值。
public int f(int n){
if(n == 0){
return 1;
}else if(n == 1){
return 4;
}else{
// return f(n + 2) - 2 * f(n + 1);
return 2*f(n - 1) + f(n - 2);
}
}
//例4：斐波那契数列 规律:从第3个数开始，每个数都等于它前两个数的和。
//fibonacci(n) = fibonacci(n-1) + fibonacci(n-2)
public int fibonacci(int n){
if (n == 1 || n == 2) {
return 1;
}else if (n > 2) {
return fibonacci(n - 1) + fibonacci(n - 2); //递归调用
}
return -1; //如果输入错误的n，一律返回-1
}
//例5：汉诺塔问题
package com.atguigu.exer1;
import java.util.Scanner;
public class Hanoi2 {
public static void main(String[] args) { //主函数
Scanner in = new Scanner(System.in);
//定义根柱子
char A = 'A';
char B = 'B';
char C = 'C';
System.out.println("**************************************************************");
System.out.println("汉诺塔问题（把A塔上编号从小号到大号的圆盘从A塔通过B辅助塔移动到C塔上去");
System.out.println("**************************************************************");
System.out.print("请输入圆盘的个数：");
//初始化盘子总数
int n = in.nextInt();
Hanoi2.hanoi(n, A, B, C);
//汉诺塔执行函数（移动细节在函数内部
System.out.println(">>移动了" + count + "次，把A上的圆盘都移动到了C上");
System.out.println("结束");
in.close();
}
static int count = 0;// 标记移动次数
// 实现移动的函数**********************
public static void move(int num, char start, char end) {
//将盘子从小到大编号，每次将编号为num的盘子，从start柱子移动到end柱子
System.out.println("第" + (++count) + " 次移动 : " + " 把 " + num + " 号圆盘从 " + start + " 柱子移动到 " + end +"号柱子上");
}
// 递归实现汉诺塔的函数*****************
public static void hanoi(int n, char A, char B, char C) {
//n为盘子总数
//默认A柱子为起始柱子
//默认B柱子为辅助柱子
//默认C柱子为终点柱子
/*
思路：
将上面n-1个盘子从A移动到B（无需思考移动细节），再将最后一个盘子（最底下最大的）先移动到终点柱C
最后只需将B柱子的n-1个盘子借助A柱子移动到C即可
*/
if (n == 1)// 圆盘只一个时，只需将其从A塔移到C塔
Hanoi2.move(1, A, C);
else{// 否则
hanoi(n - 1, A, C, B);// 递归， n-1个盘子从A移动到B，借助C
Hanoi2.move(n, A, C);// 将最后一个盘子（最下面最大的盘子）从A移动到C
hanoi(n - 1, B, A, C);// 递归，将n-1个盘子从B移动到C，借助A
}
}
}
例6：快排
四、面向对象的特征一：封装性
面向对象的特征一：封装与隐藏
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
五、类的结构之三：构造器
1.构造器（或构造方法）：Constructor
构造器的作用：
- 创建对象
- 初始化对象的信息
2.使用说明
-
如果没显式的定义类的构造器的话，则系统默认提供一个空参的构造器
-
定义构造器的格式：权限修饰符 类名(形参列表){}
-
一个类中定义的多个构造器，彼此构成重载
-
一旦我们显式的定义了类的构造器之后，系统就不再提供默认的空参构造器
-
一个类中，至少会有一个构造器。
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方法
关键字：this
1.可以调用的结构：属性、方法；构造器
2.this调用属性、方法
this理解为：当前对象 或 当前正在创建的对象
2.1 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性或方法。
但是，通常情况下，我们都择省略"this."。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式
2.2 在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用当前正在创建的对象属性或方法。但是，通常 情况下，我们都择省略"this."。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
3.this调用构造器：
① 我们在类的构造器中，可以显式的使用"this(形参列表)"方式，调用本类中指定的其他构造器
② 构造器中不能通过"this(形参列表)“方式调用自己
③ 如果一个类中有n个构造器，则最多有 n - 1构造器中使用了"this(形参列表)”
④ 规定："this(形参列表)“必须声明在当前构造器的首行
⑤ 构造器内部，最多只能声明一个"this(形参列表)”，用来调用其他的构造器
关键字：package/import
1.package的使用
1.1 使用说明：
- 为了更好的实现项目中类的管理，提供包的概念
- 使用package声明类或接口所属的包，声明在源文件的首行
- 包，属于标识符，遵循标识符的命名规则、规范(xxxyyyzzz)、“见名知意”
- 每"."一次，就代表一层文件目录。
1.2 举例：
举例一：某航运软件系统包括：一组域对象、GUI和reports子系统
举例二：MVC设计模式
<
以上是关于Java基础编程篇（4.面向对象上）的主要内容，如果未能解决你的问题，请参考以下文章