Java 入门笔记

博主： collins
发布时间：2023 年 03 月 24 日
538 次浏览
1 条评论
2951字数
分类：后端开发

#第一章：缘起
**第一章，第一幕：eclipse 引述**
eclipse创建一个Java工程 https://www.bilibili.com/video/BV135411Q7Yp/?p=2
第一章到第三章使用的教程：
Java概念篇：https://www.bilibili.com/video/BV1ES4y1z7Hj?p=20
Java实操篇：https://www.bilibili.com/video/BV1ES4y1z7Hj?p=42
第四章开始使用的教程：https://www.bilibili.com/video/BV17F411T7Ao?p=81

**与大家共同学习，共同进步！感谢我的班主任龚老师，以及哔哩哔哩黑马程序员对我成长路上的帮助。**
**希望本篇笔记，能够帮助各位在考前更好的复习**

**第一章，第二幕：有趣的见闻**
    1.1 〖你好，世界〗
    ‘只要你不失去崇高，世界将会向你敞开，就让 你好，世界 作为我们旅途的第一站吧’
    ‘Say Hello’
    public class Hello {
    ‘主程序名为 Hello.java’
    	public static void main(String[] args) {
        '每个Java程序都有且只有一个void main主程序，程序将在这里开始运行！'
    	System.out.printf("Hello，Java!");
        ‘在Java控制台打印 Hello，Java！’
    	}
    }
    1.2 〖三元运算符〗
    public class Hello {
    	public static void main(String[] args) {
    	int x = 10;
    	int y = 5;
    	int z;
    	z = (x > y) ? x : y;
    	‘如果 x > y 是真的，那么 z = x’
        ‘如果 x > y 是假的，那么 z = y’
    	System.out.println("z = "+ z);
        ‘打印 z 的结果’
    	}
    }
    1.3 〖调试框内输入数字，让它们相加〗
    import java.util.Scanner; '导入Java的Scanner类包来获取用户的输入'
    public class Hello {
    	public static void main(String[] args) {
    	Scanner sc = new Scanner(System.in);
        '创建一个Scanner，控制台会一直等待输入，
        直到敲回车键结束'
    	System.out.println("请输入第一个整数：");
        ‘要求’
    	int x = sc.nextInt();
        ‘把输入，返回给 x’
        System.out.println("请输入第二个整数：");   
        ‘这行无实质意义，仅作为文字提示’
        int y = sc.nextInt();     
        ‘把输入到控制台的数字，返回给 y’
    	System.out.println(“x+y =” + x+y);
        ‘在Java控制台里输出 x+y 的最终值’
    	}
    }

1.4 〖&和&&的区别〗
    public class Hello {
    public static void main(String[] args) {
        int x = 3;
        int y = 4;
        System.out.println((++x == 3) & (++y == 4));
    	‘如果 a & b ， 则必须 a 和 b 都为假的情况下，才返回false’	
        System.out.println((++x == 3) && (++y == 4));
        ‘如果 a && b ，不管是a 还是 b，只要有一个结果是假的，都会返回false’
        ‘如果要返回true，不管是 &还是&& 都必须 全部条件满足才行’	
        }
    }

#第二章：循环
 [第二章目录]
2.1 <a href="#if">if 基础</a>
2.2 <a href="#switch">Switch 基础</a>
2.3 <a href="#for">for 循环</a>
2.4 <a href="#while">While 用法</a>
2.5 <a href="#dreamland">循环套娃</a>
2.5 <a href="#control">控制与终止</a>

<a name="if"></a>
**第二章，第一幕：if 基础**
    2.1.0 〖if 表达式底层原理〗
    if(比较表达式){
    	如果比较表达式为真，则执行语句体;
        如果比较表达式为假，则跳出if不执行任何代码
    }
    2.1.1 〖if 可以怎么应用？〗
    public class Hello {
    	public static void main(String[] args) {
        int age = 20;
        if(age >= 18){
        【A】System.out.println("您已成年");
        '满足表达式条件时，执行【A】部分的代码'
        }
        【B】System.out.println("您未成年");
        '不满足表达式条件，执行【B部分代码】'
        }
     }

2.1.2 〖if 与 Scanner 结合〗
    '输入分数，判断在50分以上还是50分以下' 
    import java.util.Scanner;  '可以通过导入Scanner类包来获取用户的输入'
    
    public class Hello { 
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in); '创建一个Scanner，控制台会一直等待输入，
        直到敲回车键结束'
        System.out.println("请输入你的成绩");
        int x = sc.nextInt();            '将在控制台输入的成绩返回给变量x'
        if(x >= 50 && x <= 100){         '如果成绩同时满足大于等于50，小于等于100'
        System.out.println("你的分数在50分-100分之间");
        }else if(x >= 0 && x <= 49) {    '如果成绩都不满足50<x<100，
        就开始判断它是否满足 0<x<49'
        System.out.println("你的分段在00分-49分之间");
    	}
      }
    }
<a name="switch"></a>
**第二章，第二幕：Switch 基础**
    2.2.1 〖Switch 与 Scanner 结合〗
    public class Hello {
	public static void main(String[] args) {
        System.out.println("请输入季节");
        '输入春夏秋冬，打印出对应的成语'
        Scanner input = new Scanner(System.in);
        String seasons = input.next();
        ‘将得到季节，赋值给seasons’
        switch(seasons){
        'switch找seasons询问相应的季节'
        case "春":
        '如果seasons是春季，则打印下面的春季盎然，并break结束不再继续case'
        System.out.println("春季盎然");
        break;
        case "夏":
         '如果seasons是夏季，则打印下面的夏日炎炎，并break结束不再继续case'
        System.out.println("夏日炎炎");
        break;
        case "秋":
        '如果seasons是秋季，则打印下面的秋风萧瑟，并break结束不再继续case'
        System.out.println("秋风萧瑟");
        break;
        case "冬":
        '如果seasons是冬季，则打印下面的冬日暖和，并break结束不再继续case'
        System.out.println("冬日暖和");
        break;
        }
      }
    }
    2.2.2 〖Switch 与 default 结合〗
    public class Hello {
    public static void main(String[] args) {
        int x = 2; ‘定义x = 2’
        int y = 3; ‘定义y = 3’
        switch(x) { ‘开始判断x的数值了!’
        default: 'default即默认，如果case3和case4没有，就强制使用默认'
        y++; ‘如果选择默认方案，y就+1’
        break;
        case 3:y++; ‘如果x = 3，y就+1’
        case 4:y++; ‘如果x = 4，y就+1’
    }
        System.out.println("y="+y); '打印 y 的值'
      }
    }
<a name="for"></a>
**第二章，第三幕：for 基础**
    2.3.0 〖for循环的原理〗
    public class Hello {
      public static void main(String[] args){
	  for(int i = 1; i <=10 ; i++) {
          '原理：通过i从某个容器中逐个读取元素，直到没有更多元素为止。'
          '复杂的理解：for(i 的初始值 = 1，容器里最多有10个元素，记录循环读取元素的次数);'
          '简单的理解：for(初始值是1，循环10次，每次循环在原有结果上＋1);'
	  System.out.println("hello");
          '打印10次hello'	    			
      }}
    }
    2.3.1 〖for循环与if计算单复数之和〗
    public class Hello {
      public static void main(String[] args){
	  int i;
	  int a;
	  int sum = 0;
	  int dan = 0;
	  for(i = 1;i <= 100; i++) {
          ‘i循环100次’
	  a = i%2;
          '通过取余，判断单双数'
          '怎么判断?'
          '例如 100只羊50个人分，是不是刚好分完？那么余数是0，是双数。'
          '例如 100只羊51个人分，是不是刚好少了一只，那么余数是1，是单数'
	  if(a == 0){
          '如果余数是0，将执行'
	  sum = sum + i;
	  }else if(a == 1){
          '如果余数是1，将执行'
	  dan = dan + i;
	  }
     }
    	System.out.println("1-100所有复数和："+ sum);
    	System.out.println("1-100所有单数和："+ dan);
     }
    }
<a name="while"></a>
**第二章，第四幕：while 用法**
    2.4.0 〖初始化语句〗
    While(判断条件语句){
         循环体语句;
         控制条件语句;
    }
    2.4.1 〖while 循环打印〗
    public class Hello {
      public static void main(String[] args){
	  int x = 1;
	  while(x <= 10) {
          '从1开始循环，循环10次，直到不满足while条件后，跳出'
	  System.out.println("x = " + x);	
	  x++;
          ‘每循环一次 x + 1’
       }}
    }
    2.4.2 〖while 循环相加打印〗
    public class Hello {
      public static void main(String[] args){
    	    int i = 1;
    	    int sum = 0;
    	    while(i <= 100) {
            ‘当i小于或等于100时，继续循环；当i大于100时，跳出循环。’
    	    sum = sum + i;
            ‘新的和 = 旧的和 + 当前i的值’
    	    i++;
    	    System.out.println("sum = " + sum);	
            ‘打印sum新的和的变化’
       }}
    }
    2.4.3 〖do..while〗
    'while和do..while有什么区别? '
    'while倾向先判断条件是否满足，满足则开始循环，不满足则跳出'
    'do..while不管条件是否满足，都会先循环一次，然后再根据条件，判断是否开启下一轮循环'
    ‘通俗来说，while是先付款后使用，do..while允许先用后付，要是还不上钱，下次别想了。’
    public class Hello {
      public static void main(String[] args){
            int i = 1;
            ‘起始值为1’
    	    do {
            System.out.println("i = "+ i);
            ‘①每次循环打印i的值’
            i++;
            ‘②每循环一次i+1’
    	    }
    	    while (i <= 10);
            ‘③当i超过10次时，跳出循环’
            ‘不再执行 do{} 的内容’
      }
    }   ∑ 输出结果 int i = 1，2，3，4，5，6，7，8，9，10 /ᐠ｡ꞈ｡ᐟ\
<a name="dreamland"></a>
**第二章，第五幕：循环嵌套**    
    2.5.1.0 〖for for嵌套〗
    public class Hello {
      public static void main(String[] args){
            for(int i = 1;i <= 2;i++) {
            '第一个for是外循环，打印一行*'
            for(int j = 1;j <= 5;j++) {
            '第二个for是内循环，每外循环一次，内循环就要进行五次'
            System.out.print("*");
            '故外循环一次，就是在首行首个生成一个*，然后新增五列*'
            }
            System.out.println();
            '每外循环一次，空一行'
        }
      }     ∑ 输出结果 *****
    }                 ***** ฅ ˘ฅ
    2.5.1.1 〖for for嵌套 打印三角形〗
    public class Hello {
      public static void main(String[] args){
            for(int i = 1;i <= 3;i++) {
            ‘i <= 3最多打印三行*，至于每行打印多少个，问下面的for’
            for(int j = 1; j <= i ;j++ ) {
            ‘因为j每循环一次都会j++，上限取决于上面i的循环次数’
            ‘所以每循环一次，前一行比下一行多加一个*也不奇怪了’
            System.out.print("*");	
            }
            System.out.println();
           ‘外循环完毕后，换行’
          }    ∑ 输出结果 * 	
       }                 **
    }                    *** (•̀ᴗ• )

2.5.2 〖for for嵌套 九九乘法表〗
    public class Hello {
      public static void main(String[] args){
            for(int i = 1;i <= 9;i++) {
            for(int j = 1; j <= i ;j++ ) {
            'i每外循环一次递增1，每外循环一轮，则内循环 j 轮'
            'j每内循环一轮，数值在原有值上递增1'
            System.out.print(j + "*" + i + "=" + (i * j)+"| ");
            '打印 i x j = (i*j) | 结果'
            }
            System.out.println();
            ‘外循环完毕后，换行’
      }    ∑ 输出结果 1*2=2|2*2=4|	
     }     ......
    }      1*9=9|2*9=18|3*9=27|4*9=36|5*9=45|6*9=54|7*9=63|8*9=72|9*9=81|
<a name="control"></a>
**第二章，第六幕：控制与中断**
    2.6.1 〖break的使用方法〗
    ‘使用场景：break只能和switch一起用，表示中止’
    public class Hello {
      public static void main(String[] args){
            for(int x = 1;x <= 10;x++) {
            '总共循环10次'
            if (x == 4) {
            '循环到第4次的时候，break中止循环'
            break;
            }
            System.out.println("x = " + x);
            ‘打印已循环的次数’
            }  ∑ 输出结果 int = 1
       }                 int = 2
    }                    int = 3  ₊˚· ७──
    2.6.2 〖continue的使用方法〗
    '食用场景：任意循环，表示 跳过'
    public class Hello {
	public static void main(String[] args){
            for(int x = 1;x <= 10;x++) {
            if (x == 4) {
            '循环到第4次的时候'
            continue;
            ‘循环跳过’
            }
            System.out.println("x = " + x);
            ‘故不会打印 x = 4 的值’
	    }
       }    ∑ 输出结果 int(x = 1,2,3,5,6,7,8,9,10)
    }
    2.6.3 〖{name}: 锚点/标点语句〗
    public class Hello {
    public static void main(String[] args){
            a: for(int i = 1;i <= 10 ;i++) {
            'a: 是一个跳转标签; for外循环10次'
            System.out.println("i = " + i);
            b: for(int j = 1; j <= 10; j++) {
            'b: 是一个跳转标签; 外循环一次内循环10次'
            System.out.println("j = "+ j);
            break b;
            '正常情况下，内循环for应循环十次'
            '由于加了break b: 内循环只循环了一轮就被打断了'
            '所以，无论外循环循环了多少论'
            '内循环永远j = 1'
            '那如果 break a:呢？那就说明外循环一轮就被打断了'
            }
        }    ∑ 输出结果   int(x = 1,j = 1)
    }                     ......
    }                     int(x = 10,j = 1)  (•̀ᴗ• )
    2.6.4 〖return 返回〗
    public class Hello {
	public static void main(String[] args){
	    for(int i = 1;i <= 10 ;i++) {
	    if(i == 4) {
	    }
            return;
            ‘这里return了一个空值给void main主函数’
            ‘所以，不会向下执行，主函数直接返回空值。’
	   }
	    System.out.println("循环结束了");
      }          
    }       ∑ 输出结果  空值   (˶˚ ᗨ ˚˶)

#第三章：数组
 [第三章目录]
3.1 <a href="#functions">方法</a>
3.2 <a href="#sum">数组</a>
3.2.1 <a href="#3.2.1">什么是数组？</a>
3.2.2 <a href="#3.2.2">数组可以怎么用？</a>
3.2.3 <a href="#3.2.3">Java中内存分配 栈与堆</a>
3.2.4 <a href="#3.2.4">数组的静态初始化</a>
3.2.5 <a href="#3.2.5">数组越界问题和空指针问题</a>
3.3.1 <a href="#3.3.1">综合!利用for循环打印数组元素</a>
3.3.2 <a href="#3.3.2">跨方法调用数组</a>
3.3.3 <a href="#3.3.3">获取数组元素的最大值</a>
3.3.4 <a href="#3.3.4">数组的反转</a>

<a name="functions"></a>
**第三幕，第一章：方法**
    3.0 🕒〖方法概念〗
    这章概念实在太多，一度犹豫要不要跳过(•̀ᴗ• )
    那么我们要做什么呢？了解方法对应的概念
    public static void main(String[] args){}
    修饰符「public static」
    返回值类型「void」 
    方法名「main」
    参数类型「String[]」
    参数名「args」
    
    3.1 🕞〖方法概念之求和〗
    public class Hello {
	public static int qiuhe(int a,int b){
        '这个函数/方法的名字叫qiuhe'
        '他值是以int（定义整型）的方式返回的'
        '这个函数/方法里面有两个参数，一个叫int a，一个叫int b'
	    int sum = a + b;
	    'sum的值等于方法里面那两个参数相加'
	    return sum;
	    '最终将sum的值返回给函数qiuhe'
	 }
    }

3.2 🕓〖在主方法中使用子方法〗
    public class Hello {
	public static void main(String[] args) {
        '主方法名main，程序从这里开始运行'
        System.out.println(qiuhe(3,5));
        '在主方法中，向子方法qiuhe导入两个参数，分别是3和5'
        '然后打印子参数的值'
         }
	
	    public static int qiuhe(int a,int b){
        '子方法qiuhe中有两个int类型的参数，分别是a，b'
        '刚刚主方法已经导入了3和5，分别对应a，b'
        int sum = a + b;
        '相当于3+5=8'
        return sum;
        '子方法qiuhe返回的最终值为8'
        }    ∑ 输出结果
    }        主方法prinln打印结果为 8  *⸜( •ᴗ• )⸝*
    
    3.3 🕔〖比较谁的值更大，比较值是否相等〗
    public class Hello {
	public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入a的值");
            int x = sc.nextInt();
            System.out.println("请输入b的值");
            int y = sc.nextInt();
            System.out.println(x + "和" + y + "最大值是: "+ bijiao(x,y));
            System.out.println(x + "和" + y + "是否相等: " + xiangdeng(x,y));
    	}
    	
	  public static int bijiao(int a,int b){
            int sum = a > b ? a : b;
            '如果a>b是真的，sum = a'
            '如果a>b是假的，sum = b'
            return sum;
    	 }
    	
    	  public static boolean xiangdeng(int a,int b) {
            return a == b;
            '布尔boolean类型 如果a=b则返回true 如果a≠b则返回false'
            }   ∑ 输出结果 如果x=5 , y=5
      }           则x和y最大值是：5 、 x和y是否相等：true ‎|•'-'•) ✧

3.4 🕔〖重载的概念〗
    以往参数可以这样写 add(int a,int b) 来实现 a+b。
    那如果要a+b+c呢？是不得这样写 add1(int a,int b,int c)？
    以往的经验告诉我们，方法名重复是不是理所应当的认为会冲突？
    那如果要a+b+c+d呢，甚至+f呢？如果像传统那样不断更改方法名，会很乱。
    所以java推出了重载，在同一个方法名下，你可以定义不同的参数。
    例如你既可以这样写 add(int a,int b)
      也可以同时这样写 add(int a,int b,int c)
    即使不更换add这个方法名，也不会冲突，这是Java独有的，也叫做重载。

**第三幕，第二章：数组**
什么是数组？数组就是往一个罐子里装各种各样的元素。
目前学的是基本类型，只要往罐子里倒盐就好。
<a name="3.2.1"></a>
**3.2.1 理解数组**
怎么理解，反着理解，素组？？当然是吃素的猪呀，哈哈哈哈/.?@!
<img src="https://qqclwy.com/usr/uploads/2023/04/354582654.jpg" width="250"></a>
    int[] arr = new int[5]
    左边：
    int:罐头的材质，即数据类型
    []:  一个括号就是一个罐头，两个括号就是两个罐头，一堆括号就是一堆罐头。
    arr: 我就随便给你取个名字叫arr，你偏把这叫合法标识符? 你装什么高大上doge。
    右边:
    new: 对于新的生命谁不期待的，new就意味新的素组诞生。
    int: 一个塑料的罐头！
    [5]: 一个罐头里，可以放5粒猫粮，哈哈哈哈哈哈 /....,,,,!!@
<a name="3.2.2"></a>
**3.2.2 数组可以怎么用?**
    public class Hello {
    	public static void main(String[] args) {
    		int[] arr = new int [5]; 定义arr数组有5个元素 
    		
    		System.out.println(arr[0]); 打印arr数组的第0号元素
    		输出结果是：0
    		arr[0] = 10; 定义arr数组的0号元素结果为10
    		
    		System.out.println(arr[0]); 打印arr数组的0号元素
    		输出结果是：10
    	}
     }
<a name="3.2.3"></a>
**3.2.3 Java中内存分配 栈与堆**
<img src="https://qqclwy.com/usr/uploads/2023/04/2728072853.jpg" width="300"></a>
<a name="3.2.4"></a>
**3.2.4 数组的静态初始化**
    3.2.2弄一个数组打印，要历经定义数组，定义元素值，再打印元素值，很烦。
    int[] arr = new int [5]{11,22,33,44,55};  动静结合 [动]{静}
    int[] arr2 = {11,22,33,44,55};            静态初始化简写格式
    System.out.println(arr1[])            可以直接打印数组相关值
    动静结合可以拆两行写吗？当然可以！
    int[] arr;
    arr = new int[] {11,22,33,44,55}; 
    不过需要注意的是，静态初始化需要不能够拆两行，会报错！
    System.out.println(arr);
    直接打印数组名字，得到的结果就是数组在栈中的引索码。
<a name="3.2.5"></a>
**3.2.5 数组越界问题和空指针问题** 
    int[] arr = new int[5];   引索值 0x0011
    System.out.println(arr[-1]);  当堆中不存在引索，会出现索引越界异常。
    arr = null;
    System.out.println(arr[0]);  当数组引用赋值null，再去调用数组中的元素就会出现空指针
<a name="3.3.1"></a>
**3.3.1 综合! 利用for循环打印数组元素**
    int[] arr = {11,22,33,44,55};  用静态初始化定义数组
    for(int i = 0; i < 5 ; i++) {  循环5次，每次i自增1
    System.out.println(arr[i]);}   打印arr数组所包含的元素

用arr.length获取数组包含元素的数量，再进行for循环
    //arr.length 代表的是数组里最多包含多少个元素
    for(int i = 0; i < arr.length ; i++) {
    System.out.println(arr[i]);}
<a name="3.3.2"></a>
**3.3.2 跨方法调用数组**
    public static void main(String[] args) {		
    	int[] arr2 = {3,4,5}; 数组arr2有3个元素
    	print(arr2); 将数组arr2的元素值导入方法print
      }
    public static void print(int[] arr) {  接受来自arr2的值
    	for(int i = 0; i < arr.length ; i++) {
    	System.out.print(arr[i] + "");  打印arr2的值
    	}}
    }
<a name="3.3.3"></a>
**3.3.3 获取数组元素的最大值**
    public static void main(String[] args) {		
    	int[] arr = {33,11,22,44,55};  数组arr有5个元素
    	int max = getMax(arr);   将数组arr的值赋值给方法getMax
    	System.out.println(max);
    }
    	
    public static int getMax(int[] arr) {  得到arr的值
             int max = arr[0];             这行没用
             for (int i = 1; i < arr.length ;i++) {  循环最大次数
              if(max < arr[i]) {       判断arr的值是否大于max的值
              max = arr[i];
              若大于max将被赋值，若小于则跳过，直到筛选出最大值，跳出循环
             }
            }
        	return max;   方法getMax最终返回值为max，返回给main方法进行打印
        }
    }
<a name="3.3.4"></a>
**3.3.4 数组的反转**
什么是反转？把4321变成1234就叫反转，说白就是调换位置。
    public class Hello {
    	public static void main(String[] args) {		
    	int[] arr = {11,22,33,44,55}; 数组arr有5个元素
    	reverseArry(arr); 将数组arr的元素赋值给方法reverseArry
    	print(arr);
    	}
    	
    public static void reverseArry(int[] arr) {   接受到元素11，22，33，44，55
             for(int i = 0; i < arr.length / 2; i++ ) {  因为是双双交换，所以循环次数砍半
             int temp = arr[i];                     将交换值的原始值存储到变量temp中
             arr[i] = arr[arr.length-1-i];          交换值 = 被交换值
             arr[arr.length-1-i] = temp;            被交换值 = 交换值的原始值
             至此数组内部便完成一起反转，直到完成三次两两交换后跳出。
             }
        }
        
    public static void print(int[] arr) {
        	for(int i = 0;i < arr.length;i++) {
        	System.out.print(arr[i]+"");  交换完成后，对数组arr的值进行重新打印。
        	}
        }
    }

#第四章：对象
4.1 <a href="#4.1">对象</a>
4.2 <a href="#4.2">封装</a>
4.3 <a href="#4.3">封装的应用</a>
4.4 <a href="#4.4">构造方法</a>
4.5 <a href="#4.5">标准的javabean类</a>
4.6 <a href="#4.6">对象-内存图</a>
4.7 <a href="#4.7">this内存原理</a>

<a name="4.1"></a>
**4.1 对象**
<img src="https://qqclwy.com/usr/uploads/2023/04/4190012065.jpg" width="300">
以往运行一次PhoneTest.java，就只能跑PhoneTest.java的代码，如果引入对象的话，可以在PhoneTest.java里面运行Hello.java的代码。
    //文件：PhoneTest.java
    public class PhoneTest {
        //主函数，说明一切代码从这里开始运行。
	public static void main(String[] args) {
		//创建第一个对象，名字叫p，指向Hello.java
		Hello p = new Hello();
		
		//给手机赋值
		p.brand = "小米";
		p.prince = 1999.98;
		
		//打印赋值的内容
		System.out.println(p.brand);
		System.out.println(p.prince);
		
		//运行Hello.java里的代码
		p.call();
		p.playGame();
		
		//创建第二个对象，名字叫p2，指向Hello.java
		Hello p2 = new Hello();
		p2.brand = "苹果";
		p2.prince = 8999;
                System.out.println(p2.brand);
		System.out.println(p2.prince)
		//运行Hello.java里的代码
		p2.call();
		p2.playGame();
	}
    }
    //文件：Hello.java
    public class Hello {
	//属性
	String brand;
	double prince;
	//行为：
	public void call(){
		System.out.println("手机在打电话");
	}
	public void playGame() {
		System.out.println("手机在玩游戏");
	}
     }
     小米
    1999.98
    手机在打电话
    手机在玩游戏
    苹果
    8999
    手机在打电话
    手机在玩游戏
<a name="4.2"></a>
**4.2 封装**   [(゜-゜)つロ 干杯哦~][1]
<img src="https://qqclwy.com/usr/uploads/2023/04/3928327879.jpg" width="300">
封装：对象代表什么，就得封装对应的数据，并提供数据对应的行为。
如果使用场景是 人关门！
那[对象]就是门，[封装对应的数据]就是开门与关门.
[提供数据对应的行为]就是开门的时候，执行什么代码；关门的时候，执行什么代码。

pulic class Door{
    boolean flag = true; //门的状态数据
 
    public void open(){
        开门，修改门的状态
     }

public void close(){
        关门，修改门的状态
     }
    }

**4.2.1 封装的好处**
1.能够将自己的代码封装好，下次很方便的使用。
2.Java通过封装向程序员提供了很多方便的指令，直接用就不用自己写了。
这些内容涵盖在 JDK-API文档.CHM 里面。
能详细列举一下，这些方便的指令能干啥吗？可以。
例如我们要把字符'abcdef'换成大写，在没有学对象之前，我们要手把手自己写代码。
怎么写？大写与小写在ascii当中是相差32个数字的，例如A对应65，a对应97。
传统方式：就是将'abcdef'先转成ascii码，然后再-32并打印，最终得到大写的ABCDEF。
那通过Java调用对象封装的方便指令又是怎么操作的？

String s = "abcdef"; //字符串类型s
    String ss = s.toUpperCase(); //通过Java指令转换大小写
    System.out.println(ss);
    最终结果:ABCEDEF
<a name="4.3"></a>
**4.3 封装的应用**[(゜-゜)つロ 干杯哦~][2]
妈妈说的没错，蒸的好难

private 私有的，是一个权限修饰符，如果在Hello.java用了，其他的.java就无法调用了。
加这个是为了安全，那怎么给其它.java调用呢？通过set（赋值）与get（获取）。
set方法：给内部成员变量赋值 ,  get方法：对外提供成员变量的值。
    public class GirlFriend {
    	//成员变量
    	private String name;
    	//name为string字符private加密型。
    	private int age;
    	private String gender;
    	
    	//程序
    	public void sleep() {
    		System.out.println("女朋友在睡觉");
    	}
    	public void eat() {
    		System.out.println("女朋友在吃饭");
    	}
    	
    	public void setName(String name) {
    		//set+Name 赋值
    		this.name = name;
    		//this.我自己等于我自己
    	}
    	
    	public String getName(){
    		//get+Name 返回值
    		return name;
    		//如果定义对象是gf1
    		//那么引用name的值可以这样输入
    		//gf1.getName()
    	}
    	
    	public void setAge(int age) {
    		if(age >= 19 && age <= 20) {
    			this.age = age;
    			//我自己等于我自己，拿来把你。
    		}else {
    			System.out.println("非法参数");
    			//如果女朋友的年龄不在19-20岁，我会说你快忙碌起来吧。
    		}
    	}
    	public int getAge() {
    		return age;
    		//向对象返回年龄
    		//中意吗
    	}
    	
    	//gender
    	public void setGender(String gender) {
    		this.gender = gender;
    	}
    	
    	public String getGender() {
    		return gender;
    	}
    }

//文件名：GirlFriendTest.java

public class GirlFriendTest {
    	public static void main(String[] args) {
    		//创建一个女朋友对象，对象名：gf1 绑定 GirlFriend.java
    		GirlFriend gf1 = new GirlFriend();
    		//利用对象，向别的 .java 导入结果
    		gf1.setName("小诗诗"); <黑马程序员演示代码>
    		gf1.setAge(19);
    		gf1.setGender("女");
    		//利用对象，打印 别的.java 的结果
    		System.out.println(gf1.getName());
    		System.out.println(gf1.getAge());
    		System.out.println(gf1.getGender());
    		//利用对象，执行 别的.java 的代码。
    		gf1.eat();
    		gf1.sleep();
    	}
    }
<a name="4.4"></a>[(゜-゜)つロ 干杯哦~][3]
**4.4构造方法**
    🕔〖构造的原理〗
    public class Student {  定义了一个类叫Student
    	private String name; 属性一name
    	private int age;     属性二age
    	
    	public Student() { 空参构造方法
    		//...
    	}
    	
    	public Student(String name,int age) {
    		自己去定义一个带全部参数构造方法
    		//...
    	}
    }
<img src="https://qqclwy.com/usr/uploads/2023/04/2045889663.png"></a>
<a name="4.5"></a>
**4.5标准的javabean类**[(゜-゜)つロ 干杯哦~][4]
① 类名需要见名知意
② 成员变量使用private修饰
③ 提供至少两个构造方法，即public无参或带全部参数。
④ 成员方法，提供一个成员变量对应的getxxx()/getxxx()
<img src="https://qqclwy.com/usr/uploads/2023/04/2835271086.png">
<a name="4.6"></a>
**4.6对象-内存图**[(゜-゜)つロ 干杯哦~][5]
emmm...这节课，和学化学差不多，从微观的角度看，这些数据在电脑内存条里是怎么写入和处理的。
需要有点点耐心，不建议你直接看笔记，直接干杯看视频吧，哈哈。
1.Java内存分配介绍
<img src="https://qqclwy.com/usr/uploads/2023/04/4105026445.png">
2.一个对象的内存图
<img src="https://qqclwy.com/usr/uploads/2023/04/1645057040.png">
<a name="4.7"></a>
**4.7 this内存原理**[(゜-゜)つロ 干杯哦~][6]
<img src="https://qqclwy.com/usr/uploads/2023/04/2701919216.png">
<img src="https://qqclwy.com/usr/uploads/2023/04/367680463.png">
<a name="4.8"></a>
4.8 成员变量和局部变量[(゜-゜)つロ 干杯哦~][7]
<img src="https://qqclwy.com/usr/uploads/2023/04/2103323914.png">

#第五章：字符串
开章时间:2023年4月30日
**5.1 什么是API？**
什么是API？简单理解就是，直接去使用别人已经写好的代码。当然了，自己是大牛的话，也可以把自己的代码封装给别人用。大牛们的闹得这么欢，官方怎能幕后吃瓜？于是官方也开始卷起来了，写了很多方便的代码将他们打包成API给我们使用，像熟知的Scanner（键盘录入指令），Random（取随机数）都是官方向我们提供的快捷指令。本章的内卷目标也很明确啊，就是学习更多的官方快捷指令（API）。
❎jdk_api 1.9: https://wwqq.lanzouf.com/iyYYZ0ucw8fi
✅jdk_api 1.6：https://wwqq.lanzouf.com/ir15p0ucwtuj
✅jdk_api 使用方式: [(゜-゜)つロ 干杯哦~][8]
<img src="https://qqclwy.com/usr/uploads/2023/05/3921910944.png">

**5.2 字符串的四种构造方式** [(゜-゜)つロ 干杯哦~][9]
<img src="https://qqclwy.com/usr/uploads/2023/05/1244331202.png">
以上是字符串的几种表现形式，用的最多的是直接赋值，其中③字符与数组赋值，能够通过数组中的元素去改变字符串的值，其它的当了解就好了。
<img src="https://qqclwy.com/usr/uploads/2023/05/1149611591.png">
又是栈和堆？这张图可以很“直观”的说明，Java的字符串在电脑内存条中是如何交互的，可以到[(゜-゜)つロ字符串内存模型][10]直接了解哦，他那个动态ppt比我写的要直观的多。

5.2.1 字符串在内存中是如何运作的：

#滑到底部

[1]: https://www.bilibili.com/video/BV17F411T7Ao?p=83
  [2]: https://www.bilibili.com/video/BV17F411T7Ao?p=84
  [3]: https://www.bilibili.com/video/BV17F411T7Ao?p=85
  [4]: https://www.bilibili.com/video/BV17F411T7Ao/?p=86
  [5]: https://www.bilibili.com/video/BV17F411T7Ao/?p=87
  [6]: https://www.bilibili.com/video/BV17F411T7Ao/?p=89
  [7]: https://www.bilibili.com/video/BV17F411T7Ao?p=90
  [8]: https://www.bilibili.com/video/BV17F411T7Ao/?p=96
  [9]: https://www.bilibili.com/video/BV17F411T7Ao?p=98
  [10]: https://www.bilibili.com/video/BV17F411T7Ao/?p=98&t=720

最后修改：2023 年 10 月 03 日