Java基础学习笔记：第四章（一）面向对象编程

知识点1：面向对象的理解

1. 面向过程 vs 面向对象

二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

2. 类与对象的理解

面向对象中的两大核心概念 * 1. 类（class）：对一类事物的描述，是抽象的、概念上的定义。 * 2. 对象（object\instance）：由类派生(new)出的一个个的实体。

3. 学习的三条主线

面向对象编程的学习三条主线： * 1. 类及类中的成员：属性、方法、构造器；内部类、代码块 * 2. 面向对象的三个特征：封装、继承、多态、（抽象） * 3. 其它关键字的使用：this\super\import\package\static\final\abstract\interface\....

说明：

类的内部成员： * 属性 = 成员变量 = field * 方法 = 成员方法 = (成员)函数 = method

知识点2：类及对象的创建过程

* 1. 设计类，就是设计类的内部成员。。 * * 2. 设计类、创建对象、调用功能的步骤： * 第1步：创建类（实际上，就是创建类的成员:属性、方法） * 第2步：创建类的对象 （或 创建类的实例、类的实例化） * 第3步：通过"对象.属性"或"对象.方法"的方式，调用对象的内部结构 代码说明 public class PhoneTest { //测试类 public static void main(String[] args) { //数据类型 变量名 = 变量值 Scanner scan = new Scanner(System.in); // int number = scan.nextInt(); //创建Phone类的对象 Phone iphone = new Phone(); //通过"对象.属性"或"对象.方法"的方式，调用对象的内部结构 iphone.name = "苹果手机"; iphone.price = 8999; System.out.println("name:" + iphone.name + ", price:" + iphone.price); iphone.call(); iphone.sendMessage("有内鬼，停止交易！"); String info = iphone.takePhoto(); System.out.println(info); //################## Phone iphone1 = new Phone(); iphone1.name = "华为P40 pro"; iphone1.price = 4999; System.out.println("name:" + iphone1.name + ", price:" + iphone1.price); System.out.println("name:" + iphone.name + ", price:" + iphone.price); //################## Phone iphone2 = iphone; iphone2.price = 6999; System.out.println("name:" + iphone.name + ", price:" + iphone.price); //############## iphone.sendMessage("你好！很高兴认识你"); } } class Phone{ //1. 设计属性 String name;//手机名称 int price;//价格 //2. 设计方法 public void call(){ System.out.println("手机可以拨打电话"); } public void sendMessage(String message){ System.out.println("发送信息：" + message); } public String takePhoto(){ //System.out.println("拍照"); return "拍照成功"; } }

内存解析：

如果创建了类的多个对象，则每个对象拥有一套类的属性。当我们修改其中一个对象的属性时，不影响其它对象 * 此属性的值。 * * 如果将对象引用p1赋给新的变量p2，则p1和p2就共同指向了堆空间中唯一的一个对象实体。当我们通过其中一个引用 * 修改对象的属性的话，则会导致另外引用对同一个属性的值的调用。

知识点3：成员变量vs局部变量

测试类中属性的定义 * * 1. 回顾：变量的分类 * ① 按照数据类型来分： 基本数据类型（8种） vs 引用数据类型（类、数组、接口） * * ② 按照类中声明的位置： 成员变量（或属性） vs 局部变量 * 说明：成员变量：在类中直接定义的变量 * 局部变量：在方法内、构造器内、代码块内等定义的变量 * * 2. 成员变量（或属性） vs 局部变量 * 相同点： * 1. 变量声明的格式相同：数据类型 变量名 = 变量值 * 2. 凡是变量，都需要先声明，后使用 * 3. 都有其作用域。超出作用域，不可调用 * * 不同点： * 1. 声明位置的不同。 * > 成员变量：在类中直接定义的变量 * > 局部变量：在方法内、构造器内、代码块内等定义的变量 * 2. 是否可以使用权限修饰符进行修饰。 * > 权限修饰符有：private \ 缺省 \ protected \ public * > 成员变量可以使用权限修饰符进行修饰 ； * 局部变量不可以使用权限修饰符进行修饰 * > 暂时，我们在定义成员变量时，大家都使用缺省即可。（讲封装性时再说） * 3. 是否有默认初始化值的情况 * > 成员变量都有默认初始化值 * ① 如果成员变量是整型(byte\short\int\long)，则默认值为：0 * ② 如果成员变量是浮点型(float \ double)，则默认值为：0.0 * ③ 如果成员变量是boolean型，则默认值为：false * ④ 如果成员变量是char型，则默认值为：0 或 '\u0000' * ⑤ 如果成员变量是引用数据类型，则默认值为：null * * > 局部变量都没有默认初始化值。则意味着在调用局部变量之前，一定要显式的赋值。 * * 4. 在内存中存储的位置不同 * >成员变量存储在堆空间中 * >局部变量存储在栈空间中 * * @author shkstart * @create 2020-06-30 16:19 */ 代码演示 public class PersonTest { public static void main(String[] args) { Person p1 = new Person(); System.out.println(p1.name +"," + p1.age + "," + p1.gender); p1.sleep(); p1.eat("湖南臭豆腐"); Person p2 = new Person(); System.out.println(p2.age); } } class Person{ //声明成员变量(属性) String name; int age = 1; boolean gender;//性别 public void sleep(){ int hour = 6; //局部变量 System.out.println("人每天应该至少保证" + hour + "小时的睡眠"); } public void eat(String food){//food:局部变量 System.out.println("我喜欢吃：" + food); } }

知识点4：方法的声明

* 类中方法的声明测试 * 1. 之前用过的一些方法： * Scanner类的nextInt() \ next() * Math类的random() \ sqrt(double d) * Arrays类的equals(int[] arr1,int[] arr2) \ toString(int[] arr) \ sort(int[] arr) * \ binarySearch(int[] arr,int value) * * 2. 类中方法声明的格式： * 权限修饰符 返回值类型 方法名(形参列表){ * 方法体 * } * 说明：关于方法中的特殊关键字：static\final\abstract\...暂时先不考虑。 * * 3. 方法声明的详细说明： * 3.1 权限修饰符：指名当前方法被调用权限的大小。 * 涉及到的权限修饰符有：private 、 缺省 、 protected 、 public。 详细细节见《封装性》 * 目前，大家在声明方法时，默认使用public即可。 * 3.2 返回值类型 ： * > 可以分为：有具体的返回值类型 vs 没有返回值类型：void * > 有具体的返回值类型，可以使用任何的变量类型。比如：基本数据类型、引用数据类型 * > 有具体的返回值类型的方法，在调用方法结束后，一定要返回满足要求的返回值类型的变量或常量 * 补充：return的使用： * 在有具体返回值类型的方法中，一定需要使用“return + 变量/常量”的方法给方法返回指定的数据。 * 如果方法没有返回值类型，也可以使用"return;"结构，表示结束当前方法的执行。 * * 3.3 方法名：属于标识符，命名时满足标识符命名的规则和规范。“见名知意” * 3.4 形参列表： * 格式：参数类型1 参数名1,参数类型2,参数名2,... * 方法在声明时，不要给形参列表的变量赋值。当我们调用方法时，才给形参列表赋值：实参。 * 3.5 方法体：执行方法时，主要操作的逻辑。 * 4. 如何确定定义一个方法时，要不要声明返回值类型？要不要声明形参？ * ① 看题目要求。 * ② 具体问题具体分析。 代码演示 public class PersonTest { public static void main(String[] args) { Person p = new Person(); p.printNumber(); int hour = 8; p.sleep(hour); System.out.println("##############"); p.eat(); } } class Person{ String name; int age; Account acct; public void printNumber(){ for(int i = 0;i < 100;i++){ if(i == 40){ return;//用于结束方法 } System.out.println(i); } System.out.println("hello!"); } public Account getAccount(){ boolean flag = true; if(flag){ return null; } return new Account(); } public int getValue(){ return 1; // return age; } public void sleep(int hour){ System.out.println("昨天睡了" + hour + "小时"); } public void eat(){ System.out.println("人需要吃饭，补充营养"); System.out.println("name = " + name); sleep(10); // eat(); } } class Account{//账户 } 补充说明 * 5. > 可以在当前类的方法中使用当前类定义的属性或其他的方法 * > 方法内不能定义新的方法。 课后练习 /** * 2.利用面向对象的编程方法，设计类Circle计算圆的面积。 * * @author shkstart * @create 2020-07-01 11:37 */ public class CircleTest { public static void main(String[] args) { Circle c1 = new Circle(); c1.radius = 1.2; //对应方式一 // double area = c1.findArea(); // System.out.println("圆的半径为：" + c1.radius + ",面积为：" + area); //对应方式二： c1.findArea(); } } class Circle{//圆 double radius;//半径 //求圆的面积的方法 //方式一： // public double findArea(){ // return Math.PI * radius * radius; // } //方式二： public void findArea(){ System.out.println(Math.PI * radius * radius); } //错误的： // public double findArea(double r){ // return Math.PI * r * r; // } }

知识点5：方法的重载

概念的理解 * 1. 什么是方法的重载？同一个类中，相同方法名，不同参数列表的方法之间构成重载。 * * “两同一不同”：同一个类，相同方法名；参数个数 或 参数类型不同 * * 2. 方法的重载与权限修饰符、返回值类型、形参名没有关系！ 代码演示 public class OverLoadTest { public static void main(String[] args) { OverLoadTest test = new OverLoadTest(); test.show(); test.show(1,2); } public void show(){ System.out.println("hello"); } public void show(int a){ System.out.println("萨瓦迪卡"); } void show(String info){ System.out.println(info); } public int show(int i,int j){ return i + j; } private void show(int i,String info){ } public void show(String info,int i){ } // public void show(String info1,int j){ // // } // public String show(String info,int i){ // return info + i; // } } 重点 * 3. 我们在调用类中的方法时，是如何确定调用的是某一个确定的方法呢？ * 通过方法名确定 ---> 进一步通过形参列表确定

知识点6：可变形参的方法

/** * 可变形参方法的使用 * * 1. JDK5.0新增的特性。 * 2. 格式为：形参类型 ... 形参名 * 3. 当调用可变形参的方法时，实参可以为0个，1个，2个，。。。 * 4. 可变形参的方法与方法同名的其他方法之间构成重载（排除第5点) * 5. 一个类中，不能同时出现可变形参的方法 和 与其方法名相同且可变形参类型相同的数组的方法。 * 6. 如果一个方法中声明有可变形参，则可变形参一定声明在方法参数的最后。 * 7. 一个方法的形参中，最多声明一个可变个数的形参结构。 * * * @author shkstart * @create 2020-07-01 14:59 */ public class ArgsTest { public static void main(String[] args) { // int[] arr = new int[0]; ArgsTest test = new ArgsTest(); // test.show(); // test.show("abc"); test.show("abc","123","xyz"); // test.show(new String[]{"abc","def"}); } public void show(){ System.out.println("show()"); } public void show(String s){ System.out.println("show(String s)"); } public void show(int i){ System.out.println("show(int i)"); } public void show(String ... info){ System.out.println("show(String ... info)"); for(int i = 0;i < info.length;i++){ System.out.println(info[i]); } } // public void show(String[] info){ // for(int i = 0;i < info.length;i++){ // System.out.println(info[i]); // } // } //错误的 // public void show(String ... info,String i){ // // } }

知识点7：方法参数的值传递机制

1. 变量的传递机制：

* 1. 如果传递的是基本数据类型的变量，则将变量本身保存的数据值传递过去 * 2. 如果传递的是引用数据类型的变量，则将变量本身保存的地址值传递过去 public class VariableTest { public static void main(String[] args) { int m = 10; //对于基本数据类型变量来说： int n = m; n = 20; System.out.println("m = " + m);//10 //对于引用数据类型变量来说： Order o1 = new Order(); o1.num = 10; // Order o2 = o1; o2.num = 20; System.out.println("o1.num = " + o1.num); // int[] array1 = new int[]{2,3,5,7,11}; int[] array2 = array1; array2[0] = 0; System.out.println(array1[0]);//0 } } class Order{ int num; }

2. 方法形参的值传递机制

* 1. 形参：方法声明时，小括号内的参数。 * 实参：方法调用时，实际传递给形参的数据 * * 2. 如果方法的形参是基本数据类型的变量，则将实参保存的数据值传递给形参变量。 * 如果方法的形参是引用数据类型的变量，则将实参保存的地址值传递给形参变量。 基本数据类型 public class ValueTransferTest { public static void main(String[] args) { int m = 10; int n = 20; System.out.println("m = " + m + ", n = " + n); //交换两个变量的值 // int temp = m; // m = n; // n = temp; ValueTransferTest test = new ValueTransferTest(); test.swap(m,n); System.out.println("m = " + m + ", n = " + n); } public void swap(int m ,int n){ int temp = m; m = n; n = temp; } }

对应图示：

引用数据类型 public class ValueTransferTest1 { public static void main(String[] args) { Data data = new Data(); data.m = 10; data.n = 20; System.out.println("m = " + data.m +", n = " + data.n); //交换的操作 ValueTransferTest1 test = new ValueTransferTest1(); test.swap(data); System.out.println("m = " + data.m +", n = " + data.n); System.out.println(data);//com.atguigu.java1.Data@1540e19d // User user = data; } public void swap(Data data1){ int temp = data1.m ; data1.m = data1.n; data1.n = temp; } } class Data{ int m ; int n; } class User{ }

对应图示：

3. 练习1

/** * @author shkstart * @create 2020-07-01 16:23 */ public class ValueTransferTest2 { public static void main(String[] args) { int[] arr = new int[]{34, 4, 2, 6, 6, 4, 7, -87, 0, 55, 98}; System.out.println(Arrays.toString(arr)); ValueTransferTest2 test = new ValueTransferTest2(); test.sort(arr, "ascend"); System.out.println(Arrays.toString(arr)); } public void sort(int[] arr, String sortMethod) { if ("ascend".equals(sortMethod)) {//从小到大 for (int i = 0; i < arr.length - 1; i++) { for (int j = 0; j < arr.length - 1 - i; j++) { if (arr[j] > arr[j + 1]) { //最初的写法：正确 // int temp = arr[j]; // arr[j] = arr[j + 1]; // arr[j + 1] = temp; //错误的写法 // swap(arr[j], arr[j + 1]); //正确的写法 swap(arr,j,j+1); } } } } else if ("descend".equals(sortMethod)) {//从大到小 for (int i = 0; i < arr.length - 1; i++) { for (int j = 0; j < arr.length - 1 - i; j++) { if (arr[j] < arr[j + 1]) { //最初的写法：正确 // int temp = arr[j]; // arr[j] = arr[j + 1]; // arr[j + 1] = temp; //错误的写法 // swap(arr[j], arr[j + 1]); //正确的写法 swap(arr,j,j+1); } } } } else { System.out.println("排序方式错误！"); } } // public void swap(int i,int j){ // int temp = i; // i = j; // j = temp; // } public void swap(int[] arr, int i, int j) { int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } }

4.练习2：

public class TransferTest3 { public static void main(String args[]) { TransferTest3 test = new TransferTest3(); test.first(); } public void first() { int i = 5; Value v = new Value(); v.i = 25; second(v, i); System.out.println(v.i); } public void second(Value v, int i) { i = 0; v.i = 20; Value val = new Value(); v = val; System.out.println(v.i + " " + i); } } class Value { int i = 15; }

对应的图示：

补充内容：

NullPointerException的理解

/** * 关于面向对象内容中的NullPointerException的说明： * 凡是引用数据类型的变量（对象、数组）,如果取值为null时，通过此变量调用其内部结构的话，一定就是 * NullPointerException的异常。 * * @author shkstart * @create 2020-07-01 9:15 */ public class NullPointerExceptionTest { public static void main(String[] args) { User u1 = new User(); // u1 = null; // u1.name = "孔江江"; // u1.show(); System.out.println(u1.name); // System.out.println(u1.name.toString()); } } class User{ String name; int age; public void show(){ String str = null; System.out.println("我是一个用户"); } }

对象数组的理解

/** * 定义类Student，包含三个属性：学号number(int)，年级state(int)，成绩score(int)。 * 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。 * 问题一：打印出3年级(state值为3）的学生信息。 * 问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息 * * 提示： * 1) 生成随机数：Math.random()，返回值类型double; * 2) 四舍五入取整：Math.round(double d)，返回值类型long。 * * @author shkstart * @create 2020-07-01 11:56 */ public class StudentArrayTest { public static void main(String[] args) { int[] arr = new int[10]; String[] arr1 = new String[10]; // 创建20个学生对象 Student[] stus = new Student[20];//虚位以待 for (int i = 0; i < stus.length; i++) { stus[i] = new Student(); //给每一个学生的属性赋值 //学号 stus[i].number = i + 1; //年级：1-6 stus[i].state = (int)(Math.random() * 6 + 1); //成绩：0-100 stus[i].score = (int)(Math.random() * 101); } //问题一：打印出3年级(state值为3）的学生信息。 // for (int i = 0; i < stus.length; i++) { // if(stus[i].state == 3){ // stus[i].info(); // } // } //问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息 for(int i = 0;i < stus.length - 1;i++){ for(int j = 0;j < stus.length - 1 - i;j++){ if(stus[j].score > stus[j + 1].score){ Student temp = stus[j]; stus[j] = stus[j + 1]; stus[j + 1] = temp; } } } for (int i = 0; i < stus.length; i++) { stus[i].info(); } } } class Student{ int number;//学号 int state;//年级 int score;//成绩 public void info(){ System.out.println("number : " + number + ", state : " + state + ", score : " + score); } } 对应的内存解析