Java学习笔记（六）——面向对象编程（基础）

一、类与对象

（一）类与对象的概念

（二）对象内存布局

​编辑

对象分配机制

​编辑

（三）属性/成员变量

（四）创建对象与访问属性

二、成员方法

（一）方法的快速入门

（二）方法的调用机制

（三）注意事项和使用细节

（四）成员方法传参机制

克隆对象

（五）方法递归调用

四、重载（overload）

五、可变参数

六、作用域

七、构造器（构造方法）

八、this

 this的深入理解

this的注意事项和使用细节

一、类与对象

（一）类与对象的概念

对象（属性，行为）

1、类是抽象的、概念的，代表一类事物，比如人类、猫类...，即它是数据类型

2、对象是具体的、实际的，代表一个具体事物，即是实例

3、类是对象的模版，对象是类的一个个体，对应一个实例

快速入门：

public class Object01{public static void main(String[] args){// 实例化第一只猫Cat cat1 = new Cat();cat1.name = "小白";cat1.age = 3;cat1.color = "白色";// 实例化第二只猫Cat cat2 = new Cat();cat2.name = "小花";cat2.age = 5;cat2.color = "花色";// 使用：访问对象的属性System.out.println("第一只猫的信息：" + cat1.name + " " + cat1.age + " " + cat1.color);System.out.println("第二只猫的信息：" + cat2.name + " " + cat2.age + " " + cat2.color);}
}
// 定义一个猫类
class Cat {// 属性String name;int age;String color;// 行为...
}

（二）对象内存布局

对象分配机制

Java内存的结构分析：

1、栈：一般存放基本数据类型（局部变量）

2、堆：存放对象（Cat cat,数组等）

3、方法区：常量池（常量，比如字符串），类加载信息

1、先加载Person类信息（属性和方法，只会加载一次）

2、在堆中分配空间，进行默认初始化

3、把空间地址赋值给p，p就指向对象

4、进行指定初始化

（三）属性/成员变量

基本介绍：

1、从概念或叫法上看：成员变量 = 属性 = 字段field，即成员变量是用来表示属性的

2、属性是类的一个组成部分，一般是基本数据类型，也可是引用类型（对象，数组）

注意事项和细节：

1、属性的定义语法同变量，示例： 访问修饰符 属性类型 属性名;

访问修饰符控制属性的访问范围，包括：public,protected,默认,private

2、属性的定义类型可以为任意类型，包含基本类型或引用类型

3、属性如果不赋值，有默认值，规则和数组一致

（四）创建对象与访问属性

创建对象：

1、先声明再创建

        Cat cat;

        cat = new Cat();

2、直接创建

        Cat cat = new Cat();

访问属性：

        对象名.属性名;

        cat.name;

二、成员方法

（一）方法的快速入门

基本介绍：在某些情况下，需要定义成员方法（简称方法）。比如人类：除了有一些属性外（年龄、姓名...），还有一些行为：说话、跑步...这时就要用成员方法才能完成。

成员方法的好处：提高代码的复用性；可以将实现的细节封装起来，然后供其他用户来调用即可。

成员方法快速入门：

1、添加speak成员方法，输出我是一个好人

2、添加cal01成员方法，可以计算从1+...+1000的结果

3、添加cal02成员方法，该方法可以接收一个数n，计算从1+...+n的结果

4、添加getSum成员方法，可以计算两个数的和

public class Method01{public static void main(String[] args){Person p1 = new Person();p1.speak(); //调用方法p1.cal01();p1.cal02(5);int returnRes = p1.getSum(10,12);System.out.println("getSum的计算结果是：" + returnRes);}
}
class Person{String name;int age;// public:表示方法是公开的// void:表示方法没有返回值// speak():speak方法名，()形参列表// {}方法体public void speak(){System.out.println("我是一个好人");}public void cal01(){int sum = 0;for(int i = 1; i <= 1000; i++){sum += i;}System.out.println("cal01的计算结果是：" + sum);}public void cal02(int n){int sum = 0;for(int i = 1; i <= n; i++){sum += i;}System.out.println("cal02的计算结果是：" + sum);}public int getSum(int n1, int n2){int sum = n1 + n2;return sum;}
}

成员方法的定义：

public 返回数据类型 方法名(形参列表...){

        语句;

        return 返回值;

}

1、参数列表：表示成员方法输入

2、数据类型（返回类型）：表示成员方法输出，void表示没有返回值

3、方法主体：表示为了实现某一功能代码块

4、return语句不是必须的

（二）方法的调用机制

1、当程序执行到方法时，就会开辟一个独立的空间（栈空间）

2、当方法执行完毕，或者执行到return语句时，就会返回

3、返回到调用方法的地方

4、返回后，继续执行方法后面的代码

5、当main方法（栈）执行完毕，整个程序退出

（三）注意事项和使用细节

1、访问修饰符（作用是控制方法使用的范围），如果不写则默认访问。

public protected 默认 private

2、返回类型

（1）一个方法最多一个返回值（如果返回多个结果，可以返回数组）

（2）返回类型可以为任意类型，包含基本类型或引用类型（数组，对象）

（3）如果方法要求有返回数据类型，则方法体中最后的执行语句必须为return值；而且要求返回值类型必须和return的值类型一致或兼容

（4）如果方法是void，则方法体中可以没有return语句，或者只写return

3、方法名：遵循驼峰命名法，最好见名知义

4、参数列表

（1）一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开

（2）参数类型可以为任意类型，包含基本类型或引用类型

（3）调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数

（4）方法定义时的参数称为形式参数，简称形参；方法调用时的参数称为实际参数，简称实参。实参和形参的类型要一致或兼容，个数、顺序必须一致

5、方法体

里面写完成功能的具体语句，可以为输入、输出、变量、运算、分支、循环、方法调用，但里面不能再定义方法，即方法不能嵌套定义。

6、方法调用

（1）同一个类中的方法调用：直接调用即可

（2）跨类中的方法A调用B类方法：需要通过对象名调用，比如对象名.方法名(参数)

（3）跨类的方法调用和方法的访问修饰符相

（四）成员方法传参机制

1、基本数据类型的传参机制：

结论：基本数据类型传递的是值（值拷贝），形参的任何改变不影响实参

2、引用数据类型的传参机制：

结论：引用类型传递的是地址（传递也是值，但是值是地址），可以通过形参影响实参

克隆对象

例子：编写一个方法copyPerson，可以复制一个Person对象，返回复制的对象（克隆对象）。注意要求得到的新对象和原来的对象是两个独立的对象，只是他们的属性相同。

public class Method03{public static void main(String[] args){Person p1 = new Person();p1.name = "小哈";p1.age = 18;MyTools myTools = new MyTools();Person p2 = myTools.copyPerson(p1);System.out.println("p1的属性为：名字=" + p1.name + " 年龄=" + p1.age);System.out.println("p2的属性为：名字=" + p2.name + " 年龄=" + p2.age);// 可以通过对象比较来看对象是否同一个System.out.println(p1 == p1);System.out.println(p1 == p2);}
}
class Person{String name;int age;
}
class MyTools{public Person copyPerson(Person p){Person p_copy = new Person();p_copy.name = p.name;p_copy.age = p.age;return p_copy;}
}

（五）方法递归调用

递归就是方法自己调用自己，每次调用时传入不同的变量。递归有助于编程者解决复杂问题，同时可以让代码变得简介。

递归能解决的问题：

1、各种数学问题：8皇后问题，汉诺塔，阶乘问题，迷宫问题，球和篮子问题

2、各种算法中也会使用到递归，比如快排，归并排序，二分查找，分治算法等

3、将用栈解决问题

递归的重要规则：

1、执行一个方法时，就创建一个新的受保护的独立空间（栈空间）

2、方法的局部变量是独立的，不会相互影响

3、如果方法中使用的是引用类型变量（比如数组），就会共享该引用类型的数据

4、递归必须向退出递归的条件逼近，否则就是无线递归（StackOverflowError）

5、当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当方法执行完毕或者返回时，该方法也就执行完毕。

例子：

1、打印问题

public void test(int n){if(n > 2){test(n - 1);}System.out.println("n=" + n);
}

2、阶乘问题

public int factorial(int n){if(n == 1){return 1;}else{return factorial(n - 1) * n;}
}

3、斐波那契数列

1,1,2,3,5,8,13...

public int Fibonacci(int n){if(n == 1 || n == 2){return 1;}else{return Fibonacci(n - 1) + Fibonacci(n - 2);}
}

4、猴子吃桃问题

有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个。以后每天猴子都吃其中的一半，然后再多吃一个。当到第10天时，想再吃时，发现只有一个桃子了。问题：猴子吃到第day天共有多少个桃子？

public int Peach(int day){if(day == 10){return 1;}else{return (Peach(day + 1) + 1) * 2;}
}

5、老鼠走迷宫问题

public class MiGong{public static void main(String[] args){// 1、先用二维数组创建迷宫// 2、规定数组的元素值：0表示可以走，1表示障碍物int map[][] = new int[8][7];// 设置障碍for(int i = 0; i < 7; i++){map[0][i] = 1;map[7][i] = 1;}for(int i = 0; i < 8; i++){map[i][0] = 1;map[i][6] = 1;}map[2][1] = 1;map[2][2] = 1;map[2][4] = 1;map[3][2] = 1;map[3][3] = 1;// 输出当前地图for(int i = 0; i < map.length; i++){for(int j = 0; j < map[i].length; j++){System.out.print(map[i][j] + " ");}System.out.println();}// 使用findWay给老鼠找路T t = new T();t.findWay(map, 1, 1);System.out.println("找路情况：");for(int i = 0; i < map.length; i++){for(int j = 0; j < map[i].length; j++){System.out.print(map[i][j] + " ");}System.out.println();}}
}
class T {// 使用递归回溯的思想解决老鼠出迷宫// 该方法目的是找出迷宫的路径// (i,j)是老鼠的位置，初始位置是(1,1)// 因为是递归找路，所以先规定map数组的各个值含义：0表示可以走，1表示障碍物，2表示走过，3表示走不通// 当map[6][5] = 2就说明找到通路，就可以结束，否则就继续找// 确定老鼠找路策略：下->右->上->左 （策略对结果有影响）public boolean findWay(int map[][], int i, int j){if(map[6][5] == 2){ //说明已经找到return true;}else{if(map[i][j] == 0){  //表示可以走// 假定可以走通map[i][j] = 2;// 使用找路策略，来确定该位置是否真的可以走通if(findWay(map, i + 1, j)){ //向下走return true;}else if(findWay(map, i, j + 1)){ //向右走return true;}else if(findWay(map, i - 1, j)){ //向上走return true;}else if(findWay(map, i, j - 1)){ //向左走return true;}else{map[i][j] = 3;return false;}}else{  // map[i][j] == 1/2/3return false;}}}
}

6、汉诺塔问题

public class HanoiTower{public static void main(String[] args){Tower tower = new Tower();tower.move(5,'A','B','C');}
}
class Tower {// num表示要移动的盘子，a、b、c表示A塔、B塔、C塔public void move(int num, char a, char b, char c){if(num == 1){ //如果只有一个盘System.out.println(a + "->" + c);}else{// 如果有多个盘，可以看成只有两个盘：最下面的盘和上面的所有盘// (1)先移动上面所有的盘到b（借助c）move(num - 1, a, c, b);// (2)把最下面的盘移动到cSystem.out.println(a + "->" + c);// (3)再把b的所有盘移动到c（借助a）move(num - 1, b, a, c);}}
}

四、重载（overload）

java中允许同一个类中，多个同名方法的存在，但要求形参列表不一致。比如：System.out.println(); out是PrintStream类型。

重载的好处：

1、减轻了起名的麻烦

2、减轻了记名的麻烦

注意事项和使用细节（同名不同参）：

1、方法名：必须相同

2、形参列表：必须不同（参数类型或个数或顺序，至少有一样不同，参数名无要求）

3、返回类型：无要求

public class OverLoad01{public static void main(String[] args){MyCalculator mc = new MyCalculator();System.out.println(mc.caculate(10,12));System.out.println(mc.caculate(10.10,12));System.out.println(mc.caculate(10,12.10));System.out.println(mc.caculate(2000,10,12));}
}
class MyCalculator{public int caculate(int n1, int n2){return n1 + n2;}public double caculate(int n1, double n2){return n1 + n2;}public double caculate(double n1, int n2){return n1 + n2;}public int caculate(int n1, int n2, int n3){return n1 + n2 + n3;}
}

五、可变参数

java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。可以通过可变参数实现。

基本语法：

访问修饰符 返回类型 方法名(数据类型... 形参名){

}

public class VarParameter01{public static void main(String[] args){Method method = new Method();System.out.println(method.sum(10,12,56));}
}
class Method{// int... 表示接受的是可变参数，类型是int，即可以接收多个int(0-多)// 使用可变参数时，可以当做数组来使用，即nums可以当做数组public int sum(int... nums){// System.out.println("接收的参数个数=" + nums.length);int res = 0;for(int i = 0; i < nums.length; i++){res += nums[i];}return res;}
}

注意事项和细节：

1、可变参数的实参可以为0个或任意多个

2、可变参数的实参可以为数组

3、可变参数的本质就是数组

4、可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后

5、一个形参列表中只能出现一个可变参数

六、作用域

介绍：

1、在java编程中，主要的变量就是属性（成员变量）和局部变量

2、局部变量一般是指在成员方法中定义的变量

3、java中作用域的分类

全局变量：也就是属性，作用域为整个类体

局部变量：也就是除了属性之外的其他变量，作用域为定义它的代码块中

4、全局变量可以不赋值，直接使用，因为有默认值；局部变量必须赋值后，才能使用，因为没有默认值。

注意事项和细节：

1、属性和局部变量可以重名，访问时遵循就近原则

2、在同一个作用域中，比如在同一个成员方法中，两个局部变量不能重名

3、属性生命周期较长，伴随着对象的创建而创建，伴随着对象的销毁而销毁。局部变量生命周期短，伴随着它的代码块的执行而创建，伴随着代码块的销毁而销毁，即在一次方法调用过程中。

4、作用域不同

全局变量：可以被本类使用，或其他类使用（通过对象调用）

局部变量：只能在本类中对应的方法中使用

5、修饰符不同

全局变量/属性可以加修饰符

局部变量不可以加修饰符

七、构造器（构造方法）

需求：前面在创建对象时，是先把一个对象创建好后，再给他的年龄和姓名属性赋值，如果现在要求在创建对象时，就直接指定这个对象的年龄和姓名，这时就可以使用构造器。

介绍：构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。

基本语法：

修饰符 方法名(形参列表){

        方法体;

}

public class Constructor01{public static void main(String[] args){Person person = new Person("Smith",80);System.out.println("name=" + person.name + " age=" + person.age);}
}
class Person{String name;int age;// 构造器public Person(String pName, int pAge){name = pName;age = pAge;}
}

注意事项和使用细节：

1、构造器的修饰符可以默认，也可以是public protected private

2、构造器没有返回值

3、方法名和类名字必须一样

4、参数列表和成员方法一样的规则

5、构造器是完成对象的初始化，并不是创建对象。在创建对象时，系统会自动调用该类的构造器完成对象的初始化

6、一个类可以定义多个不同的构造器，即构造器重载。比如：可以再给Person类定义一个构造器，用来创建对象的时候，只指定人名不指定年龄。

7、如果程序员没有定义构造器，系统会自动给类生成一个默认无参构造方法（也叫默认构造方法），比如Dog(){}，使用javap指令反编译看看。

javap是jdk提供的一个命令行工具，能对给定的class文件提供的字节代码进行反编译。

8、一旦定义了自己的构造器，默认的构造器就覆盖了，就不能再使用默认的无参构造器，除非显式的定义一下，即Person(){} 

对象创建流程分析：

1、加载Person类信息(Person.class)，只会加载一次

2、在堆中分配空间（地址）

3、完成对象初始化（先默认初始化age=0 name=null，再显式初始化age=90 name=null，最后是构造器的初始化age=20 name="小倩"）

4、在对象在堆中的地址返回给p（p是对象名，也可以理解成是对象的引用）

八、this

构造器中的name = name; age = age;都是局部变量。

 

this介绍：java虚拟机会给每个对象分配this，代表当前对象。

 this的深入理解

java中没有办法直接获取到实际地址（因为是在虚拟机里的，是虚拟地址），可以使用hashCode来获取哈希值。

 

简单来说， 哪个对象调用，this就代表哪个对象。

this的注意事项和使用细节

1、this关键字可以用来访问本类的属性、方法、构造器

2、this用于区分当前类的属性和局部变量

3、访问成员方法的语法：this.方法名(参数列表);

（两种方法有区别，在继承里会涉及） 

4、访问构造器语法：this(参数列表);  注意只能在构造器中使用，即只能在构造器中访问另外一个构造器。而且必须放在第一条语句。

5、this不能在类定义的外部使用，只能在类定义的方法中使用