免责声明：java基础资料均来自于韩顺平老师的《循序渐进学Java零基础》教案，具体视频内容可以去B站观看，这些资料仅用于学习交流，不得转载用于商业活动
1.java面向对象：类
类与对象释义：
- 类是抽象的，概念的，代表一类事物。例如人类，宠物类，即它是数据类型
- 对象是具体的，实际的，代表一个具体的事物，即是实例
- 类是对象的模板，对象是类的一个个体，对象是一个实例
1.1 属性/成员变量/字段
从概念或叫法上看：成员变量=属性=field(字段)(即 成员变量是用来表示属性的)
class Car{
String name;//属性，成员变量，字段filed
double price;
String color;
String[] master;//属性可以是基本数据类型，也可以是引用类型
}
说明：
- 属性是类的一个组成部分，一般是基本数据类型，也可以是引用类型(对象，数组)。
- 属性的定义语法同变量，如：访问修饰符 属性类型 属性名；
- 属性定义的类型可以为任意类型，包括基本类型和引用类型
- 属性如果不赋值，有默认值，规则和数组一致
- 具体来说：int 0,short 0,byte 0,long 0,float 0.0,double 0.0,char \u0000,boolean false,String null
1 public class PropertiesDetail {
2 public static void main(String[] args) {
3 //创建Person对象
4 //p是对象名（对象的引用）
5 //new Person() 创建对象空间(数据)，才是真正的对象
6 Person p=new Person();
7
8 //对象默认值
9 System.out.println("当前这个人的信息是");
10 System.out.println("age="+p.age+" name="+p.name
11 +" sal="+p.sal+" isPass="+p.isPass);
12 }
13 }
14
15 class Person{
16 int age;
17 String name;
18 double sal;
19 boolean isPass;
20 }
访问属性：
基本语法
对象名.属性名
cat.name;
cat.age;
cat.color;
1.2 对象
如何创建对象
1)先声明再创建
Cat cat;//声明对象cat
cat=new Cat();//创建
2)直接创建
Cat cat=new Cat();
1.3 类和对象的内存分配机制
1 public class PropertiesDetail {
2 public static void main(String[] args) {
3 //创建Person对象
4 //p是对象名（对象的引用）
5 //new Person() 创建对象空间(数据)，才是真正的对象
6 Person p1=new Person();
7
8 p1.age=10;
9 p1.name="小明";
10 Person p2=p1;
11 System.out.println(p2.age);
12 //对象默认值
13 System.out.println("当前这个人的信息是");
14 System.out.println("age="+p.age+" name="+p.name
15 +" sal="+p.sal+" isPass="+p.isPass);
16 }
17 }
18
19 class Person{
20 int age;
21 String name;
22 double sal;
23 boolean isPass;
24 }
Java内存的结构分析：
- 栈：一般存放基本数据类型(局部变量)
- 堆：存放对象(Cat cat,数组)
- 方法区：常量池(常量，比如字符串)，类加载信息
Java创建对象的流程简单分析
- 先加载Person类信息(属性和方法信息，只会加载一次)
- 再堆中分配空间，进行默认值初始化(看规则)
- 把地址分配给p1,p1就指向对象
- 进行指定初始化 p1.name="小明" p1.age=10
1.4 成员方法
1.4.1 基本介绍
在某些情况下，我们需要定义成员方法（简称方法）。比如人类：除了有一些属性外（年龄，姓名...）我们人类还有一些行为
比如：可以说话，吃饭，睡觉。这时就要用成员方法才能完成。现在要求完善 Person类
1 public class Method01 {
2 public static void main(String[] args) {
3 //方法使用
4 //1.方法写好后，如果不去调用(使用)，不会输出
5 //2.先创建对象，然后调用方法即可
6 Person p1=new Person();
7 p1.speak();//调用方法
8 p1.sleep();
9
10 //调用work方法，同时task="任务1"
11 //把work方法的繁殖赋值给变量reslut
12 String result=p1.work("任务1");
13 System.out.println("work方法返回的值="+result);
14 }
15 }
16
17 class Person{
18 int age;
19 String name;
20 double sal;
21 boolean isPass;
22
23 // 方法(成员方法)
24 //添加speak 成员方法，输出"今天天气很好呀！"
25 public void speak(){
26 System.out.println("今天天气很好呀！");
27 }
28
29 //添加睡觉方法
30 public void sleep(){
31 System.out.println("呼噜噜...");
32 }
33
34 //打工人：老大给你任务了，完成今日的工作，并汇报结果
35 public String work (String task){
36 System.out.println("接收到任务："+task);
37 System.out.println("努力工作中");
38
39 return "boss,我的工作完成了，工作成功已经发送到您的邮箱，请查收";
40 }
41 }
方法的调用机制原理：
成员方法的好处：
1) 提高代码的复用性
2) 可以将实现的细节封装起来，然后供其他用户来调用即可
1.4.2 成员方法的定义
访问修饰符 返回数据类型 方法名(形参列表){//方法体
语句;
return 返回值;
}
- 形参列表：表示成员方法输入 work(String task),cal(int n),add(int num1,int num2)
- 返回数据类型：表示成员方法输出，void表示没有返回值
- 方法主体：表示为了实现某一功能的代码块
- return语句不是必须的
注意事项和使用细节：
- 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数
- 实参和形参的类型要一致或兼容，个数，顺序必须一致
- 方法不能嵌套定义
返回数据类型：
- 一个方法最多有一个返回值
- 返回类型可以为任意类型，包含基本类型和引用类型
- 如果方法要求有返回数据类型，则方法体中最后的指向语句必须为return 值
- 返回值类型必须和return的值类型一致或兼容
- 如果方法是void,则方法体中可以没有return语句，或者只写return;
形参列表:
- 一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开，例如 getSum(int n1,int n2)
- 参数类型可以为任意类型，包含基本类型和引用类型 例如：printArr(int[][] map)
- 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数
- 方法定义时的参数称为形式参数，简称形参；方法调用时传入的参数称为实际参数，简称实参
- 实参和形参的类型要一致或兼容，个数，顺序必须一致
方法体：
里面写完成功能的具体的语句。可以输入、输出、变量、运算、分支、循环、方法调用，
但里面不能再定义方法！即：方法不能嵌套定义
方法调用细节说明：
- 同一个类中的方法调用：直接调用即可，如：print(参数)
- 跨类中的方法A调用B类方法：需要通过对象名调用，如 p1.work("任务1")
- 特别说明一下：跨类的方法调用和方法的修饰符有关
1.4.3 成员方法的传参机制
1 class AA{
2 //细节：方法不能嵌套定义
3 public void f4(){
4 //错误
5 //public void f5(){
6
7 //}
8 }
9
10 public void swap(int a,int b){
11 System.out.println("a和b交换前的值\na="+a+"\tb="+b);//a=10,b=20
12 //完成了a和b的交换
13 int temp=a;
14 a=b;
15 b=temp;
16 System.out.println("a和b交换前的值\na="+a+"\tb="+b);//a=20,b=10
17 }
18 }
19
20 public class MethodParameter01 {
21 public static void main(String[] args) {
22 int a=10;
23 int b=20;
24 //创建AA对象 名字 aa
25 AA aa=new AA();
26 aa.swap(a,b);
27 System.out.println("main方法 a="+a+"\tb="+b);//a=10,b=20
28 }
29 }
基本数据类型，传递的是值（值拷贝），形参的任何改变不影响实参
1 public class MethodParameter02 {
2 public static void main(String[] args) {
3 //测试
4 B b=new B();
5 int[]arr={1,2,3};
6 b.test100(arr);//调用方法
7 System.out.println("main的arr数组");
8 //遍历数组
9 for (int i = 0; i < arr.length; i++) {
10 System.out.println(arr[i]+"\t");
11 }
12 System.out.println();
13
14 //测试
15 Person p=new Person();
16 p.name="jack";
17 p.age=10;
18 b.test200(p);
19
20 System.out.println("main的p.age="+p.age);//1000
21 }
22 }
23
24 class B{
25 public void test200(Person p){
26 p.age=1000;//修改对象属性
27 //思考
28 p=new Person();
29 p.name="tom";
30 p.age=99;
31 //思考
32 //p=null
33 }
34
35 public void test100(int[] arr){
36 arr[0]=200;//修改元素
37 //遍历数组
38 System.out.println("test100的arr数组");
39 for(int i=0;i<arr.length;i++){
40 System.out.println(arr[i]+"\t");
41 }
42 System.out.println();
43 }
44 }
引用类型传递的是地址，（传递的也是值，但是值是地址），可以通过形参影响实参
1.4.4 方法的递归调用（非常非常重要，比较难）
基本介绍
简单的说：递归就是方法自己调用自己，每次调用时传入不同的变量，递归有助于编程者解决复杂问题，同时可以让代码变得简洁
递归能解决什么问题？
- 各种数学问题,如8皇后问题，汉诺塔，阶乘问题，迷宫问题等等
- 各种算法中也会使用到递归，比如快排，归并排序，二分查找，分治算法等
- 将用栈解决的问题-》递归代码比较简洁
1 public class Recursion01 {
2 public static void main(String[] args) {
3 T t1=new T();
4 t1.test(4); //输出神农？n=2,n=3,n=4
5 int res=t1.factorial(5);
6 System.out.println("5的阶乘 res="+res);
7 }
8 }
9
10 class T{
11
12 public void test(int n){
13 if(n>2){
14 test(n-1);
15 }
16 System.out.println("n="+n);
17 }
18
19 public int factorial(int n){
20 if(n==1){
21 return 1;
22 }else {
23 return n * factorial(n-1);
24 }
25 }
26 }
递归重要规则：
- 执行一个方法时，就创建一个新的受保护的独立空间（栈空间）
- 方法的局部变量是独立的，不会相互影响，比如变量n
- 如果方法中使用的是引用类型变量（比如对象，数组），就会共享该引用类型的数据
- 递归必须向退出递归的条件逼近，否则就是无限递归，出现（StackOverflowError）
- 当一个方法执行完毕，或者遇到renturn，就会返回，遵守谁调用，就将结果返回给谁
- 当方法执行完毕或者返回时，该方法也就执行完毕了
递归案例1：斐波拉契数列
1 //斐波拉契数1,1,2,3,5,8,13...
2 public int fibonacci(int n){
3 if(n>=1){
4 if(n>2){
5 return fibonacci(n-1)+fibonacci(n-2);
6 }else {
7 return 1;
8 }
9 }else {
10 System.out.println("要求输入的数为正整数");
11 return -1;
12 }
13 }
14
15 public class RecursionExercise01 {
16 public static void main(String []args){
17 T t1=new T();
18 int n=6;
19 int res=t1.fibonacci(n);
20 System.out.println("当n="+n+"对应的斐波拉契数="+res);//8
21
22 }
23 }
递归案例2：迷宫问题
1 //使用递归回溯的思想解决老鼠出迷宫
2 //1.findWay方法就是专门用来找出迷宫的路径
3 //2.如果找到，就返回true,否则返回false
4 //3.map就是二维数组，即表示迷宫
5 //4.i,j就是老鼠的位置，初始化的位置为（1，1）
6 //5.因为我们是递归的找路，所有我们先规定map数组的各个值的含义
7 //0 表示可以走 1表示障碍物 2表示可以走 3表示走过，但是走不通是死路
8 //6.当map[6][5]=2 就说明找到通路，就可以结束
9 //7.先确定老鼠找路策略 下->右->上->左
10 public boolean findWay(int[][] map,int i,int j){
11 if(map[6][5]==2){//说明已找到
12 return true;
13 }else{
14 if(map[i][j]==0){//当前这个位置0，说明表示可以走
15 //我们假定可以走通
16 map[i][j]=2;
17 //使用找路策略，来确定该文职是否真的可以走通
18 //下->右->上->左
19 if(findWay(map,i+1,j)){//先走下
20 return true;
21 }else if(findWay(map,i,j+1)){//右
22 return true;
23 }else if(findWay(map,i-1,j)){//上
24 return true;
25 }else if(findWay(map,i,j-1)){//左
26 return true;
27 }else {
28 map[i][j]=3;
29 return false;
30 }
31 }else {//map[i][j]=1,2,3
32 return false;
33 }
34 }
35 }
36
37 //修改找路策略，看看路径是否有变化
38 //下->右->上->左==> 上->右->下-左
39 public boolean findWay2(int[][]map,int i,int j){
40 if(map[6][5]==2){//说明已经找到
41 return true;
42 }else {
43 if(map[i][j]==0){//当前这个位置0，说明表示可以走
44 //我们假定可以走通
45 map[i][j]=2;
46 // 使用找路策略，来确定该位置是否真的可以走通
47 //上->右->下-左
48 if(findWay2(map,i-1,j)){//先走上
49 return true;
50 }else if(findWay2(map,i,j+1)){//右
51 return true;
52 }else if(findWay2(map,i+1,j)){//下
53 return true;
54 }else if(findWay2(map,i,j-1)){//左
55 return true;
56 }else {
57 map[i][j]=3;
58 return false;
59 }
60 }else {//map[i][j]=1,2,3
61 return false;
62 }
63 }
64 }
65
66 public class Maze {
67 public static void main(String[] args) {
68 //思路
69 //1.先创建迷宫，用二维数组表示int[][]map=new int[8][7]
70 //2.先规定map数组的元素值：0表示可以走 1表示障碍物
71 int[][]map=new int[8][7];
72 //3.将上面的一行和最下面的一行，全部设置为1
73 for(int i=0;i<7;i++){
74 map[0][i]=1;
75 map[7][i]=1;
76 }
77 //将最右边的一列和最左边的一列，全部设置成1
78 for(int i=0;i<8;i++){
79 map[i][0]=1;
80 map[i][6]=1;
81 }
82 map[3][1]=1;
83 map[3][2]=1;
84 map[2][2]=1;
85
86 //输出当前地铁
87 System.out.println("======当前地图情况======");
88 for(int i=0;i<map.length;i++){
89 for(int j=0;j<map[i].length;j++){
90 System.out.print(map[i][j]+" ");//
91 }
92 System.out.println();
93 }
94
95 //使用findWay给老鼠找路
96 T t1=new T();
97 t1.findWay(map,1,1);
98 System.out.println("\n====找路的情况如下====");
99 for(int i=0;i<map.length;i++){
100 for(int j=0;j<map[i].length;j++){
101 System.out.print(map[i][j]+" ");//输出一行
102 }
103 System.out.println();
104 }
105 }
106 }
递归案例3：汉诺塔传说
汉诺塔：汉诺塔(又称为河内塔)问题是源于印度一个古老传说的益智玩具。大梵天创造世界的时候做了三根金刚石柱子，在一根
柱子上从下往上按照大小顺序摞着64片圆盘。大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。并且
规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。
假如每秒钟移动一次，共需要多长时间呢？移完这些金片需要5845.54亿年以上。太阳系的预期寿命据说也就是数百亿年。
真的过了5845.54亿年，地球上的一切声明，连同梵塔、庙宇等，都早已经灰飞烟灭
1 public class HanoiTower {
2 public static void main(String[] args) {
3 Tower tower=new Tower();
4 tower.move(64,'A','B','C');
5 }
6 }
7
8 class Tower{
9
10 //方法
11 //num表示要一定的个数,a,b,c分别表示A塔，B塔，C塔
12 public void move(int num,char a,char b,char c){
13 //如果只有一个盘 num=1
14 if(num==1){
15 System.out.println(a+"->"+c);
16 }else{
17 //如果又多个盘，可以看成两个，最下面的和上面的所有盘（num-1）
18 //（1）先移动上面所有的盘到b,借助c
19 move(num-1,a,c,b);
20 //(2)把最下面的这个盘，移动到c
21 System.out.println(a+"->"+c);
22 //(3)再把b塔上所有盘，移动到c,借助a
23 move(num-1,b,a,c);
24 }
25 }
26 }
递归案例4：八皇后问题
八皇后问题说明
八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯*贝瑟尔于1848年提出
在8*8格的国际象棋上摆放8个皇后，使其不能互相攻击，即：任意两个皇后都不能处于同一行、同一列活同一斜线上，问又多少种摆法
1 public class Queen8Question {
2 private final int max=8;
3 private int arr[] =new int[max];
4 private static int count=0;
5 private static int resultCount=0;
6 public static void main(String[] args) {
7 Queen8Question queen8Question=new Queen8Question();
8 queen8Question.play(0);
9
10 System.out.println("判断了"+count+"次");
11 System.out.println("结果有"+resultCount+"种");
12 }
13
14 //八皇后思路分析
15 //1.第一个皇后先放第一行第一列
16 //2.第二个皇后放在第二行第一列，然后判断是否ok,如果不ok,继续放在第二列，第三列，一次把所有列都放完，找到一个合适的
17 //3.继续在第三个皇后，还是第一列，第二列...直到第8个皇后也能放在一个不冲突的位置，算是找到了一个正确解
18 //4.当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，即将第一个皇后，放到第一列的所有正确解，全部得到
19 //5.然后回头继续第一个皇后放第二列，后面继续循环执行1，2，3，4的步骤
20 //说明：理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，用一个一维数组即可解决问题
21 //arr[8]={0,4,7,5,2,6,1,3}
22 //对应arr下标，表示第几行，即第几个皇后 arr[i]=val,val表示第i+1个皇后，放在第i+1行的第val+1列
23 public void play(int n){
24 //完成第8个皇后的摆放，退出递归方法
25 if(n==max){
26 printResult();
27 return;//结束本轮皇后摆放，回溯到第一个皇后继续下一轮游戏
28 }else{
29 //遍历列
30 for(int i=0;i<max;i++){
31 arr[n]=i;
32 //摆放皇后厚判断位置是否合法
33 if(isRight(n)){
34 //如果不冲突就继续摆放下一个皇后
35 play(n+1);
36 }
37 }
38 }
39 }
40
41 public boolean isRight(int n){
42 count++;
43 for(int i=0;i<n;i++){
44 //如果在同一列则冲突
45 //如果在同一斜线也冲突，在同一斜线 说明 行-行=列-列 也就是 x=y x为行距 y为列距离
46 if(arr[i]==arr[n]||Math.abs(n-i)==Math.abs(arr[n]-arr[i])){
47 return false;
48 }
49 }
50 return true;
51 }
52
53 //打印8个皇后摆放的结果
54 public void printResult(){
55 resultCount++;
56 for (int i : arr){
57 System.out.print(i+" ");
58 }
59 System.out.println();
60 }
61 }
1.5 方法重载（OverLoad）
基本介绍
Java中也允许同一个类中，有多个同名方法的存在，但要求形参列表不一致
比如：System.out.println();out是PrintStream类型
重载的好处
1）减轻了起名的麻烦
2）减轻了记名的麻烦
1 public class MyCalculator {
2 public static void main(String[] args) {
3 //println()的重载
4 System.out.println(100);
5 System.out.println("hello world");
6 System.out.println('h');
7 System.out.println(1.1);
8 System.out.println(true);
9
10 MyCalculator mc=new MyCalculator();
11
12 //calculate()重载
13 System.out.println(mc.calculate(1,2));
14 System.out.println(mc.calculate(1.1,2));
15 System.out.println(mc.calculate(1,2.5));
16 System.out.println(mc.calculate(1,2,3));
17 }
18
19 //下面是四个calculate方法构成了重载
20 //两个整数的和
21 public int calculate(int n1,int n2){
22 System.out.println("calculate(int n1,int n2)被调用");
23 return n1+n2;
24 }
25
26 //没有构成方法重载，仍然是错误的，因为是方法的重复定义
27 // public void calculate(int n1,int n2){
28 // System.out.println("calculate(int n1,int n2)被调用");
29 // int res= n1+n2;
30 // }
31
32 //没有构成重载，而是方法的重复定义
33 // public int calculate(int a1,int a2){
34 // System.out.println("calculate(int a1,int a2)被调用");
35 // return a1+a2;
36 // }
37
38 //一个整数，一个double的和
39 public double calculate(int n1,double n2){
40 System.out.println("calculate(int n1,double n2)被调用");
41 return n1+n2;
42 }
43
44 //一个double,一个int和
45 public double calculate(double n1,int n2){
46 System.out.println("calculate(double n1,int n2)被调用");
47 return n1+n2;
48 }
49
50 //三个int的和
51 public int calculate(int n1,int n2,int n3){
52 System.out.println("calculate(int n1,int n2,int n3)被调用");
53 return n1+n2+n3;
54 }
55 }
注意事项和使用细节：
- 方法名：必须相同
- 形参列表：必须不同（形参类型或个数或顺序，至少有一样不同，参数名无要求）
- 返回类型：无要求
1.6 可变参数
基本概念
Java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法
就可以通过可变参数实现
基本语法：
访问修饰符 返回类型 方法名(数据类型... 形参名){
}
1 public class VarParameter01 {
2 public static void main(String[] args) {
3 ComputMethod cm=new ComputMethod();
4 System.out.println(cm.sum(1,5,100));//106
5 System.out.println(cm.sum(1,19));//20
6 }
7 }
8
9 class ComputMethod{
10 //可计算2个数的和，3个数的和，4，5
11 //可以使用方法重载
12 // public int sum(int n1,int n2){//2个数的和
13 // return n1+n2;
14 // }
15 // public int sum(int n1,int n2,int n3){//3个数的和
16 // return n1+n2+n3;
17 // }
18 // public int sum(int n1,int n2,int n3,int n4){//4个数的和
19 // return n1+n2+n3+n4;
20 // }
21 // ...
22 //上面的三个方法名称相同，功能相同，参数个数不同-》使用可变参数优化
23 //1.int... 表示接受的是可变参数，类型是int,即可以接受多个int(0-多)
24 //2.使用可变参数时，可以当作数组来使用 即nums 可以当作数组
25 //3.遍历nums求和即可
26 public int sum(int... nums){
27 System.out.println("接收的参数个数="+nums.length);
28 int res=0;
29 for (int i = 0; i < nums.length; i++) {
30 res+=nums[i];
31 }
32 return res;
33 }
34
35 }
注意事项和使用细节：
- 可变参数的实参可以为0个活任意多个
- 可变参数的实参可以为数组
- 可变参数的本质是数组
- 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
- 一个形参列表中只能出现一个可变参数