java 学习笔记---1

2021/12/28

1.常用的DOS命令

DOS操作系统的命令，是一种面向磁盘的操作命令，主要包括目录操作类命令、磁盘操作类命令、文件操作类命令和其它命令。 用于在操作窗口下操作文件

• 打开命令提示符窗口 （1.快捷键： win+R；2.输入cmd；3.回车）
• 常用的操作

操作	说明
盘符+：	进入其他盘 例如 e:
dir	查看当前路径下的目录
cd+目录	进入单极目录
cd+…	退出单极目录
cd\目录1\目录2…	进入多级目录
cd +\	退出所有目录
cls	清屏
exit	退出窗口

2 配置path环境变量

- Q:why要配置它 path是啥玩意？？

• Ans：因为我们如果用dos命令进入某一个文件夹，就得一直cd 太麻烦了 有了path ，就可以方便使用javac和Java命令。

- 咋配？
1.进入配置设置

2.配置JAVA_HOME变量

3.配置path变量

4.检验是否配置成功（直接在dos窗口输入 javac 看是否出现信息）

3.Hello World 案例（记事本）

• 开发Java程序的三个步骤：编写程序、编译程序、运行程序；
• 步骤
  1.用记事本新建文本文档，修改名称为Hello World.java
  2.在里边编写程序
  3.在dos窗口下运行 titi

我也不知道为啥我运行不出来 还是用idea

2021/12/29

4.注释

• 单行注释 格式：//注释信息
• 多行注释 格式：/注释信息/
• 文档注释 格式/****/

5.关键字

是什么 ？ 被java语言赋予特殊含义的单词
特点？ 关键字的字母全小写； 一般关键字在解释器里有颜色，很特别；

6.常量

是什么？ 在程序运行过程中其值不可以改变的量；

常量类型	说明
字符串	用双引号括起来的 eg:“nihao”
整数	int
小数	float
字符	单引号括起来的 char
布尔	bool true false
空	null

7.数据类型

计算机存储是什么？ 计算机设备最小的信息单元叫“位（bit）”； 计算机设备最小的存储单元是“字节（Byte）”；
Java中的数据类型？ Java是强数据类型，对于每一种数据都给出了明确的数据类型，不同的数据类型也分配了不同的存储空间，所以表示数据大小也不同；

8.变量

是什么？ 在程序运行过程之中其值可以发生改变的量，从本质上来说变量是内次中的一小块。
组成部分？ 数据类型+变量名+变量值； eg： char a =10;
变量的使用？ 取值和修改值；
**注意事项？**在使用long类型的时候超出int范围的数要在后边加一个“L”为了防止小数类型不兼容float后边加“F”；

9.标识符

是什么？ 给类，方法，变量等起名字的符号；
注意事项？

• 组成部分：数字，字母，下划线和美元符号；
• 不能用数字开头；
• 不能是关键字；
• 区分大小写；

约定？

1. 标识符是一个单词时，首字母小写；比如：name；（小驼峰）
2. 标识符是多个字母，第一个字母小写其他单词首字母大写；比如：firstName；（小驼峰）
3. 标识符是一个单词时，首字母大写；比如：Name；（大驼峰）
4. 标识符是多个字母，每一个单词首字母大写；比如：FirstName；（大驼峰）

//小驼峰命名法是针对方法和变量；大驼峰是针对类来命名的；

10.类型转换

各种数据类型表示范围比较： byte 自动类型转换： 把一个表示范围小的数值或者变量赋值给另一个表示数据范围大的变量；例如：double d = 10;
强制数据类型转换： 把一个表示范围大的数值或者变量赋值给另一个表示数据范围小的变量；格式：目标数据类型 变量名 = （目标数据类型）值或者变量；例如：int k =(int)88.88;

11.运算符

是什么？ 运算符：对常量或者变量进行操作的符号； 表达式：用用运算符把常量和变量链接起来的式子，不同运算符体现不同表达式；
类？ 算数运算符，赋值运算符，自增自减运算符，关系运算符（由于条件判断），逻辑类型（连接关系运算符），三元运算符；
特别的
1.字符的加减，是字符的ascll码的数值加减，且可以和整数浮点数进行算数运算；

2.字符串进行加法运算是拼接操作，运算有顺序；
3.三元运算符：格式： 关系表达式？表达式1：表达式2； 例子： a>b?a:b;

2021/12/31

12.数据输入

数据输入的类：Scanner ；

步骤：
1.导包 “import java.util.Scanner;”
2.创建对象 “Scanner sc = new Scanner(System.in);”
3 .接收数据 “int i = sc.nextInt();”

注：Util是utiliy的缩写，是一个多功能、基于工具的包。 java.util是包含集合框架、遗留的collection 类、事件模型、日期和时间设施、国际化和各种实用工具类(字符串标记生成器、随机数生成器和位数组、日期Date类、堆栈Stack类、向量Vector类等)。

案例：三个和尚比身高

13.分支语句

1.The-流程语句：在程序中各条语句的执行顺序对程序执行的结果有直接影响，我们通过控制语句的执行来实现程序的功能，最常见的流程：自上而下的顺序执行；
2.分类： 顺序结构(自上而下依次)；分支结构(if,switch)；循环结构(for，while，do…while);
3.switch格式及说明：

switch(表达式){   ///表达式可以是byte，short，int，char，枚举；
	case 值1:  //case后边跟的是和表达式比较的值。
		语句体1;  
		break;  //表示中断，结束switch语句；
	case 值2:
		语句体2;
		break;
	...
	default:  //所以的case都不匹配时执行default；（默认）
		语句体 n+1;
		[break;]
		
}

4.for循环的语句格式

for(初始化语句;条件判断语句;条件控制语句){
	循环语句体;
}

5.while循环语句格式

while(条件判断语句){
	循环体语句;
	条件控制语句;
}

6.do…while语句格式

do{  //至少要执行一次 
	循环体语句;
	条件控制语句;
}while(条件判断语句);

3.案例：
（if）小明的奖励：

（switch）春夏秋冬

import java.util.Scanner;
public class ChunXiaQiuDong {
    //从键盘录入月份输出这个月份的季节；
    //春：345 夏：678 秋：9 10 11 冬：1，2，12；
    public static void main(String[] args) {
        System.out.println("请输入一个月份");
        Scanner sc = new Scanner(System.in);
        int month = sc.nextInt();
        switch (month){
            case 3:
            case 4:
            case 5:
                System.out.println("夏");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("秋");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("冬");
                break;
            case 12:
            case 1:
            case 2:
                System.out.println("春");
                break;
            default:
                System.out.println("有误");

        }

    }
}

(for)输出数据

（for）水仙花数：

(while)珠穆朗玛峰

2022/1/1

14.跳转控制语句

• continue：在循环中跳过某次循环，继续执行下一条循环
• break：直接终止整个循环
  区别：

15.Random

The-用于产生一个随机数；
使用步骤：
1.导包： “import java.util.Random;”;
2.创建对象：“Random r = new Random();”;**
3.获取随机数**：“int x = r.nextInt(10)”;

例子:猜数字程序

import java.util.Random;
import java.util.Scanner;
public class GassNum {
    public static void main(String[] args) {
        //程序自动生成一个1到一百的数字，使用程序实现猜这个数字是几；
        Random r = new Random();
        int n = r.nextInt(101)+1;
        System.out.println("请输入您猜的数字：");
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        while (x!=n){
            if (x<n){
                System.out.println("猜小了请重新输入：" );
                x = sc.nextInt();
            }
            else {
                System.out.println("猜大了请重新输入：");
                x = sc.nextInt();
            }
        }
        System.out.println("猜对了哈哈，这个数就是："+x);

    }
}

16.IDEA中的快捷键

• 快速生成语句：
  1.快速生成main方法：“psvm”+回车；
  2.快速生成输出语句：“sout”+回车；
• 内容辅助键：
  1.Ctrl+Alt+space(内容提示，代码补全)；
• 快捷键：
  1 单行注释：选中代码，Ctrl+/
  2 多行注释：选中代码，Ctrl+Shift+/
  3 格式化：Ctrl+Alt+L

Idea有关的操作：黑马57

17.数组定义格式

1.需求：一次性声明大量存储数据变量；且存储的数据都是同类型的数据；
2.定义：用于存储多个相同类型数据存储模型；
3.定义格式： 格式一： 数据类型[ ] 变量名；格式二：数据类型 变量名[ ];

public class ShuZu {
    public static void main(String[] args) {
        //数组的两种定义
        
        int[] arr; //格式1  推荐
        //定义了一个int类型的数组，数组名是arr；
        
        int lrr[];
        //定义了一个int类型的变量，变量名是lrr数组;
    }
}

4.数组初始化的方式

1. 动态初始化：初始化时只指定数组长度，由系统分配初始值;
   格式： 数据类型[ ] 变量名 = new 数据类型[数组长度];

//动态初始化
        int[] arr = new int[10];
        /*左边：
                int:说明数组中的元素是int类型的；
                [ ]:说明这是一个数组；
                arr:这是数组的名称；
          右边：
                new:为数组申请内存空间；
                int:说明数组中的元素类型是int类型；
                [ ]:说明这是一个数组；
                10:说明数组长度其实就是数组中的元素个数； 
                */

2. 静态初始化： 初始化时指定每个元素初始值，由系统决定数组长度；
   格式：数据类型[ ] 变量名 = new 数据类型[ ]{ 数据1，数据2，…};

//静态初始化
        int[] arr = new int[]{1,2,3,6};
        int[] lrr = {1,2,3,6};  //简写格式

获取数组中元素的数量： arr.length;

18.方法

1.是什么？
类型于函数，就是将具有独立功能的代码块组织成一个整体，具有独特功能的代码集；
2.注意事项？
方法必须先创建才可以使用，该过程成为方法的定义；
方法的创建并不直接运行，需要手动使用才执行，成为方法的调用；
方法在类下边；
3.方法的定义：
格式：

public static 返回值类型 方法名(参数){ 
       方法体;
       return 数据;
    }
/*
	public static   修饰符
	返回值类型       方法操作完毕后返回的数据的数据类型；
	方法名      		调用方法的标识；
	参数			由数据类型和变量名组成，多个参数用逗号隔开；
	方法体  			完成功能时的代码块；
	return			用于返回；
*/

4.例子 最简单的方法调用（判断是否为偶数）

public class FangFa {
    public static void main(String[] args) {
        isEventNumber();//在main函数中调用方法；
    }

    public static void isEventNumber(){
        //定义一个方法判断一个数是不是偶数
        int number = 10;
        if(number%2==0){
            System.out.println(true);
        }
        else {
            System.out.println(false);
        }
    }
}

import java.util.Scanner;

public class Input {  //输入一个整数
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        System.out.println(isEvent(a));
    }

    public static boolean isEvent(int num) {//判断奇偶
        if (num % 2 == 0) {
            return true;
        } else {
            return false;
        }
    }
}

例子2：判断两个数大小

public class MaxNum {
    public static void main(String[] args) {
        getMax();
    }
    public static void getMax() {
        int a = 100;
        int b = 200;
        System.out.println(a>b?a:b);
    }
}

5.带参数的方法定义

public static void 方法名(参数) {  //带参数方法的格式
        方法体
    }
    public static void 方法名(数据类型 变量名) {  //单个参数
        方法体
    }
    public static void 方法名(数据类型 变量名1 ,数据类型变量名2) { //多个参数
        方法体
    }

例子（单个参数）判断偶数

public class FangFa {
    public static void main(String[] args) {
        int x = 10;
        isEventNumber(x);
    }
    public static void isEventNumber(int number){
        //定义一个方法判断一个数是不是偶数
        if(number%2==0){
            System.out.println(true);
        }
        else {
            System.out.println(false);
        }
    }
}

例子（多个参数）判断两数大小

public class MaxNum {
    public static void main(String[] args) {
        getMax(158,692); //实参
    }
    public static void getMax(int a,int b) {  //形参
        System.out.println(a>b?a:b);
    }
}

6.带返回值方法的调用

public static 数据类型  方法名(参数) {
        return 数据;  //return后边的返回值必须和方法上的数据类型一致
    }
//方法的返回值通常是在main函数中定义变量接收

注意：
方法是平级关系不能嵌套，也就是说方法里边不能套方法；
void 表示无返回值，可以省略return，也可以单独书写return，后边不加数据；
形参的修改不会影响实参的值，但对于引用类型的参数（比如数组类型），形参会影响实参的值；

19.方法的重载

是什么？：
在同一个类中定义多个方法，这些方法之间的关系，满足：
1.多个方法在同一个类中
2.多个方法具有相同的方法名；
3.多个方法的参数不同，类型不同，数量不同；

特点？
1.重载仅对应方法的定义，与方法的调用无关；
2.仅针对同一个类中的方法名称与参数进行识别，与返回值无关，不能通过返回值来判断方法是否重载；
3.在调用的时候java虚拟机会通过参数的不同区分同名的方法；

为什么要用方法重载？
这是java的三大特征之一的多态的表现形式；具有兼容性；
//三大特征：封装继承多态；

2022/1/2

20.数组的遍历

例子1：遍历一个数组要求输出在一行上

新的输出语句："System.out.print( “内容” ); "
//不换行

例子2：用方法实现数组中的最大值

public class MaxNum {
    public static void main(String[] args) {
        int[] arr = {45,89,6,3,475,999,1023,874,36};
        int max = getMax(arr);
        System.out.println(max);
    }
    public static int getMax(int[] arr) {
        int flag = 0;
        for (int i = 0;i<arr.length;i++){
            flag = arr[flag]>arr[i]?flag:i;
        }
        return arr[flag];
    }
}

21.Debug

1.是什么？
提供程序调试的工具，它用于查看程序的执行流程，也可以用于追踪程序执行过程来调试程序；
2.流程？
加断点；运行加断点的程序；观察；删除断点；

22.综合例题

例子1：逢七过

public class Jump7 {
    public static void main(String[] args) {
        //逢七过，输出1~100 ，但是碰到含有7的或者7的倍数的 要说过！

        for (int i = 1;i<=100;i++){
            if(i%10==7||i/10==7|| i%7==0){
                System.out.print("过！"+" ");
            }
            else{
                System.out.print(i+" ");
            }
        }
    }
}
/*1 2 3 4 5 6 过！ 8 9 10 11 12 13 过！ 15 16 过！
 18 19 20 过！ 22 23 24 25 26 过！ 过！ 29 30 31 
 32 33 34 过！ 36 过！ 38 39 40 41 过！ 43 44 45 
 46 过！ 48 过！ 50 51 52 53 54 55 过！ 过！ 58 
 59 60 61 62 过！ 64 65 66 过！ 68 69 过！ 过！ 
 过！ 过！ 过！ 过！ 过！ 过！ 过！ 过！ 80 81 82 
 83 过！ 85 86 过！ 88 89 90 过！ 92 93 94 95 96 
 过！ 过！ 99 100 */

例子2：不死神兔

public class NoDieRabbit {
    public static void main(String[] args) {
        //有一对兔子，从出生的第三个月起每个月都生一对兔子，小兔子张到第三个月也是每个月又生一对
        //假如兔子都不死，问这20个月兔子的对数为多少？
        int[] arr = new int[20];
        arr[0] = 1;
        arr[1] = 2;
        System.out.println("第"+1+"个月的兔子个数为"+arr[0]);
        System.out.println("第"+2+"个月的兔子个数为"+arr[1]);
        for (int i = 2; i < arr.length; i++) {
            arr[i] = arr[i - 2] + arr[i - 1];
            System.out.println("第"+(i+1)+"个月的兔子个数为"+arr[i]);
        }

    }
}
/*规律：
*       第一个月：1
*       第二个月：1
*       第三个月：2    =====>斐波那契数列
*       第四个月：3
*       第五个月：5
* */


第20个月的兔子个数为10946

例子三：百钱百鸡

public class MoneyChicken {
    public static void main(String[] args) {
        //公鸡5块钱一只，母鸡3块钱一只，小鸡1块钱三只。问 100块钱分别能买多少只公鸡母鸡和小鸡？
        int g, m, x;
        for (g = 0; g <= 20; g++) {
            for (m = 0; m <= 33; m++) {
                x = 100 - g - m;
                if (x % 3 == 0 && g * 5 + m * 3 + x / 3 == 100) {
                    System.out.println("公鸡的个数是：" + g + "母鸡的个数是：" + m + "小鸡的个数是：" + x * 3);
                }
            }
        }
    }
}

例子4：数组元素求和

public class ShuZuYuanSuQiuHe {
    public static void main(String[] args) {
        //求数组元素的和 满足：各位和十位都不能是7 且只能是偶数
        int[] arr = {68,27,95,88,171,996,51,210};
        int sum = 0;
        for(int i = 0;i<arr.length;i++){
            if(arr[i]%2==0&&arr[i]%10!=7&&(arr[i]/10)%10!=7){
                sum+=arr[i];
            }
        }
        System.out.println(sum);  //1362
    }
}

例子5：数组内容相同

public class SameShuZu {
    public static void main(String[] args) {
        //设计一个方法，用于判断两个数组内容是否相同
        int[] arr = {1,2,3,5};
        int[] brr = {1,2,3,5};
        System.out.println(biJiao(arr,brr));
     }

    public static boolean biJiao(int[] a,int[] b) {
        if(a.length!=b.length){
            return false;
        }
        for (int i = 0;i<a.length;i++){
            if(a[i]!=b[i]){
                return false;
            }
        }
        return true;
    }
}

例子6：查找

import java.util.Scanner;

public class ChaZhao {
    public static void main(String[] args) {
        //已知一个静态数组，输入一个数查找它在数组中的索引
        int[] arr = {19, 28, 37, 46, 50};
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数：");
        int x = sc.nextInt();
        int count = 0;
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == x) {
                System.out.println("该数在数组中的索引是：" + i);
                break;
            }
            count = count + 1;
            if (count == arr.length) {
                System.out.println("数组中没有你要的数！！");
            }

        }
    }
}

2022/1/3
例子7：反转

public class FanZhuan {
    public static void main(String[] args) {   //单指针
        int[] arr = {19,28,37,46,50,60};
        int flag;
        if (arr.length%2==0){  //偶数长度
            flag = arr.length/2-1;
        }
        else {                  //奇数长度
            flag = arr.length/2;
        }
        for (int i = 0;i<=flag;i++){
            swap(arr,i,arr.length-1-i);
        }
        for (int j = 0;j<arr.length;j++){
            System.out.print(arr[j]+" ");
        }
    }
    public static void swap(int[] arr,int a,int b) {   //交换方法
        int t = 0;
        t = arr[a];
        arr[a] = arr[b];
        arr[b] = t;
    }
}

public class FanZhuan {
    public static void main(String[] args) {   //双指针
        int[] arr = {19,28,37,46,50};
        int start,end;
        for (start = 0,end = arr.length-1;start<=end;start++,end--){
            int temp = 0;
            temp = arr[start];
            arr[start] = arr[end];
            arr[end] = temp;
        }
        for (int j = 0;j<arr.length;j++){
            System.out.print(arr[j]+" ");
        }
    }
}

例子8：评委打分

import java.util.Scanner;

public class DaFen {
    public static void main(String[] args) {
        //6个评委打分，去掉最高分 最低分取其他四个评委的平均值
        //注：分数是0-100的整数
        Scanner sc = new Scanner(System.in);
        int[] arr = new int[6];
        System.out.println("请输入六位评委的打分：");
        for (int i=0;i<6;i++){
            arr[i] = sc.nextInt();
        }
        int jg = (summ(arr)-minn(arr)-maxx(arr))/4;
        System.out.println("评分结果为："+jg);
    }

    public static int minn(int[] arr) {
        int min = 0;
        for (int i=1;i<6;i++){
            if (arr[i]<arr[min]){
                min = i;
            }
        }
        return arr[min];
    }
    public static int maxx(int[] arr) {
        int max = 0;
        for (int i=1;i<6;i++){
            if (arr[i]>arr[max]){
                max = i;
            }
        }
        return arr[max];
    }
    public static int summ(int[] arr) {
        int sum = 0;
        for (int i=0;i<6;i++){
            sum += arr[i];
        }
        return sum;
    }
}

23.类和对象

1.什么是面向对象？

“面向对象的方法主要是把事物给对象化，包括其属性和行为。 面向对象编程更贴近实际生活的思想。 总体来说面向对象的底层还是面向过程，面向过程抽象成类，然后封装，方便使用就是面向对象，（万物皆对象）。”

即：面向具体的数据信息；
2.什么是类？

是对现实生活中一类具有共同属性和行为的事物的抽象；

即：面向对象的数据信息的类型；
3.什么是对象的属性？

属性：对象具有各种特征，每个对象的每个属性都拥有特定的值；

4.什么是对象的行为？

行为：对象能够执行的操作；

5.类和对象的关系？

类是抽象的，对象是具体的；
类是对象的抽象，对象是类的实体；

6.类的定义？
类的重要性：类是Java程序的基本组成部分；
类的组成：属性和行为；

• 属性：在类中通过成员变量来体现（类中方法外的变量）
• 行为：在类中通过成员方法来体现（和前边的方法比较去掉static变量）
  
  2022/1/4

/*
*  定义一个手机类:
* */

public class Phone {   //类名

    //成员变量
    String brand; //品牌
    int price;      //价格

    //成员方法
    public void call(){ //打电话
        System.out.println("喂~");
    }
    public  void sendMessage(){  //发短信
        System.out.println("你好!");
    }
}

7.对象数为使用

要在main方法中使用	

//创建对象:

• 格式: 类名 对象名 = new 类名();
• 例子:Phone p = new Phone();

//使用对象

• 格式: 对象名.变量名; //使用成员变量
• 范例:p.brand;
• 格式:对象名.方法名(); //使用成员方法
• 范例:p.call();

public class PhoneDemo {
    public static void main(String[] args) {

        //创建对象
        Phone p = new Phone();

        //使用成员变量
        System.out.println(p.brand);   //直接输出是默认值
        System.out.println(p.price);

        //赋值成员变量
        p.brand = "苹果";
        p.price = 15000;

        System.out.println(p.brand);
        System.out.println(p.price);

        //使用成员方法
        p.call();
        p.sendMessage();
    }
}

8.案例: 学生
要求:定义一个学生类,然后定义一个学生测试类,在学生测试类中通过对象完成成员变量和成员方法的使用;

public class Student {  //学生类

    String name;  //成员变量
    int age;

    public void study(){  //成员方法
        System.out.println("我是学生,我爱学习!");
    }
    public void doHomeWork(){
        System.out.println("写作业,明天要交555");
    }
}

public class StudentDemo {
    public static void main(String[] args) {
        //测试学生类

        Student mn = new Student();  //创建对象

        mn.name = "美丽动人的妮妮";   //成员变量赋值
        mn.age = 22;
        System.out.println(mn.name+","+mn.age); //输出成员变量

        mn.study();    //输出成员方法
        mn.doHomeWork();
    }
}

9.成员变量vs局部变量

1. 成员变量:类中方法外的变量;
2. 方法变量:方法中的变量;
   
   3.成员变量和局部变量的区别

区别	成员变量	局部变量
类中位置不同	类中方法外	类中方法内
内存位置不同	堆内存	栈内存
生命周期不同	随着对象的存在或消失	随着方法调用存在或消失
初始值不同	有默认的初值	无默认值,必须先定义在赋值才能使用

24.封装

1.why?
通过对象名直接访问成员变量存在着数据安全;
2.封装:

隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读取和修改的访问级别。
封装是面向对象的三大特征之一(多态/封装/继承);
具体是:将某些信息隐藏在类内部,不允许外部程序直接访问,而是通过该类提供的方法实现对隐藏信息的操作和访问成员变量private,提供对应的方法;

封装的好处:
通过方法来控制成员变量,提高了代码的安全性;把代码进行封装,提高了代码的复用性;
3. private关键字: 是一个权限修饰符;可以修饰成员变量;作用是保护成员不被别的类使用,被private修饰的成员仅在本类中才能访问;
5. 针对private修饰的变量的操作:
//提供"get变量名()"方法,用于获取成员变量的值,方法用public修饰;
//提供"set变量名(参数)"方法,用于设置成员变量的值,方法用public修饰;


解决方法


5.this关键字
用于在使用set方法的时候,局部变量和成员变量重名,解决局部变量隐藏成员变量;this用于指代成员变量,方法被哪工变量调用,this就代表哪个对象;
比如:

改进方法:

这里:用this修饰指代成员变量,不用this的就是局部变量;

6.构造方法
作用: 创建对象; 功能:完成对象数据的初始化;

格式:
        修饰符 类名(参数){   //修饰符一般用public
        
        }

注意事项:
//当一个类中没有给出构造方法,系统会默认的给出一个默认的无参构造方法;
//如果定义了构造方法,系统将不再通过默认的构造方法;

    public Student(){}  //无参构造方法

构造方法的特点:
1.方法名相同参数不同;(构造方法的重载)

public class Student {  //学生类

    String name;  //成员变量
    private int age;

    public void show() { //成员方法
        System.out.println(name + "," + age);
    }

    public Student() {   //无参构造方法(默认)
    }

    public Student(String name) {   //  构造方法
        this.name = name;
    }

    public Student(int age) {      //构造方法
        this.age = age;
    }

    public Student(String name, int age) {   //构造方法
        this.age = age;
        this.name = name;
    }
   }

public class StudentDemo {
    public static void main(String[] args) {
        //测试学生类

        Student s1 = new Student();  //创建对象
        s1.show();
        Student s2 = new Student("meini");
        s2.show();
        Student s3 = new Student(18);
        s3.show();
        Student s4 = new Student("zhaolongjie",24);
        s4.show();
    }
}

7.标准类的制作

1. 成员变量 : 使用private修饰
2. 成员方法: 提供一个无参构造方法;提供一个带多参的构造方法;
3. 构造方法:提供每一个成员变量对应的set和get方法;提供一个显示对象信息的方法show;
4. 创建对象并为其成员变量赋值的两种方式
   (1).无参构造方法创建对象后使用 set和get方法进行赋值;
   (2).使用带参构造方法直接创建带有属性值的对象;

太卡了写不下了,续集连接
笔记1：https://blog.csdn.net/meini32/article/details/122195422
笔记2：https://blog.csdn.net/meini32/article/details/122321446
笔记3：https://blog.csdn.net/meini32/article/details/122381565
笔记4：https://blog.csdn.net/meini32/article/details/122784859
笔记5：https://blog.csdn.net/meini32/article/details/125783677
笔记6：https://blog.csdn.net/meini32/article/details/125895927
笔记7：https://blog.csdn.net/meini32/article/details/125977036

学习目录：https://blog.csdn.net/meini32/article/details/126057619