JavaSE基础

最新推荐文章于 2023-02-27 08:14:49 发布

hello蜗牛

最新推荐文章于 2023-02-27 08:14:49 发布

阅读量65

点赞数

本文链接：https://blog.csdn.net/weixin_45662838/article/details/118707205

版权

一、java基础再次学习

java三大版本

Write Once、Run Anywhere
JavaSE:标准版(桌面程序,控制台开发…….)

JavaME:嵌入式开发(手机,小家电…)
JavaEE: E企业级开发(web端，服务器开发…)

标识符

关键字：（不能用于命名）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sbPxrml6-1626170137951)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210708150721569.png)]

注意点

所有的标识符都应该以字母(A-Z或者a-z),美元符( $) 、或者下划线开始首字符之后可以是字母 (A - Z 或者 a - z), 美元符（$ )、下划线（_）或数字的任何字符组合不能使用关键字作为变量名或方法名。
标识符是大小写敏感的
合法标识符举例: age.$salary、_value、_1_value

非法标识符举例:123abc、-salary、#abc

可以用中文命名。但是不建议这样去使用。

数据类型

float
有限 离散 舍入误差 大约   接近但不等于

最好完全使用浮点数进行比较

最好完全使用浮点数进行比较

最好完全使用浮点数进行比较

浮点数拓展?
银行业务怎么表示?钱
使用 BigDecimal 数学工具类

字符拓展

   char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);
        System.out.println((int)c1); //强制换行
        System.out.println(c2);
        System.out.println((int)c2);//强制换行

//所有的字符本质还是数字

结果是：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xgR3SJK2-1626170137952)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210708161914724.png)]

转义字符

//        \t 制表符
//        \n  换行
//        .....

类型转换

由于Java是强类型语言，所以要进行有些运算的时候的，需要用到类型转换。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zOyZl7uX-1626170137953)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210708165941638.png)]

运算中

//强制类型转换   方法：（类型）变量名    高到低
        int i = 223;
        byte e = (byte) i;
        System.out.println(e);

//自动类型转换               低到高
int t = 223;
double y = t ;
System.out.println(y);

注意点:
1.不能对布尔值进行转换
2．不能把对象类型转换为不相干的类型
3．在把高容量转换到低容量的时候，强制转换4．转换的时候可能存在内存溢出，或者精度问题!

JDK7 新特性，数字之间可以用下划线分隔开

int num=10_0000_0000;
System.out.println(num);

输出：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7TVJVX8D-1626170137955)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210708223604473.png)]

变量

变量是什么:就是可以变化的量!
Java是一种强类型语言，每个变量都必须声明其类型。
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-2hpK68Lx-1626170137956)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210708224014847.png)]

注意事项

每个变量都有类型，类型可以是基本类型，也可以是引用类型。

变量名必须是合法的标识符。
变量声明是一条完整的语句，因此每一个声明都必须以分号“ ; ”结束

变量作用域

类变量

实例变量

局部变量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tjzicQyx-1626170137958)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210708224928907.png)]

public class One {
//    类变量：表示static
    static double salary=22;
    //    属性：（变量）

//    实例变量//实例变量:从属于对象;如果不自行初始化，这个类型的默认值int为0，double为（0.0）// 布尔值:默认是false

//除了基本类型，其余的默认值都是nuLl ;
String name;
    int age;


//main 方法
    public static void main(String[] args) {
//    局部变量：必须声明和初始化值
        int i=10;
        System.out.println(i);

//实例变量
//        变量类型变量名字= new 类名();
        One one=new One();
        System.out.println(one.age);
        System.out.println(one.name);
        
//        类变量      static
        System.out.println(salary);
}
}

常量

常量(Constant):初始化(initialize)后不能再改变值!不会变动的值。
所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

final 常量名 =值；

final double  PI=3.14；

注意：常量名一般使用大写字符

变量的命名规范

所有变量、方法、类名:见名知意
类成员变量:首字母小写和驼峰原则: monthSalary

局部变量:首字母小写和驼峰原则
常量:大写字母和下划线:MAX_VALUE
类名:首字母大写和驼峰原则: Man, GoodMan方法名:首字母小写和驼峰原则: run(), runRun()

自增自减

三元运算符

字符串连接符 + ，string

        int a=10;
        int b=12;
//        字符串连接符  +  ，string
        System.out.println(" "+a+b);  //表示字符串拼接
        System.out.println(a+b+" ");//表示加法运算

包机制

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lWfQXcVt-1626170137958)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210709080802176.png)]

JavaDOC文档标注

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p5EsKJnL-1626170137959)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210709081355470.png)]

Scanner

        Scanner scanner = new Scanner(System.in);
        System.out.println("next用于接收键盘数据的输入");
        //判断用户有没有输入字符串
        if (scanner.hasNext()) {
            //使用next方式接收
            String str = scanner.next();
            System.out.println("输入的内容为：" + str);
        }
//             凡是属于IO流的类要及时关闭，否则会占用资源。
        scanner.close();

结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-SzqgwObH-1626170137960)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210709093435538.png)]

C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210709093928193.png)

嵌套的if语句

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-06YSjbiA-1626170137960)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210710175306106.png)]

Switch 多选择结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-selRVpSN-1626170137961)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210710175838482.png)]

何谓方法?

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iIQr3hmg-1626170137961)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210712165700672.png)]

方法的定义

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-39UZHQxH-1626170137961)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210712191130796.png)]

方法调用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-aFM9oE7B-1626170137962)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210712200437153.png)]

public class Demo9 {
    public static void main(String[] args) {
        int max=max(12,39);
        System.out.println(max);
    }
//一个比较大小的方法
    public static int max(int num1, int num2) {
        int result = 0;
        if (num1 == num2) {
            System.out.println("num1==num2");
            return 0;
        }
        
        if (num1 > num2) {
            result = num1;
        } else {
            result = num2;
        }
        return  result;

    }

}

方法重载

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-NWyj2RzH-1626170137962)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210712201619759.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a6UBUbZo-1626170137963)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210712202608121.png)]

命令行传参数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-amtOnEDk-1626170137963)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210712203125457.png)]

可变参数

JDK 1.5开始，Java支持传递同类型的可变参数给一个方法。

在方法声明中，在指定参数类型后加一个省略号(.…)。
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-wz47s2ml-1626170137964)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210712203804270.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7p5fzEsC-1626170137964)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210712205008047.png)]

递归

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R7JtNj7V-1626170137965)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210712205813846.png)]

数组定义

数组是相同类型数据的有序集合.

数组描述的是相同类型的若干个数据,按照一定的先后次序排列组合而成。

其中,每一个数据称作一个数组元素,每个数组元素可以通过一个下标来访问它们.

数组声明创建

int [] array;
    
int [] array=new int[10];

数组的三种初始化

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-onI6K65B-1626170137965)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210712220928983.png)]

//        静态初始化
        int [] array={1,2,3,34,5};
//        动态初始化
        int [] array1=new int[10];
        array1[0]=1;
        array1[1]=3;

数组的四个基本特点

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6vRu4Zuy-1626170137966)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210712215009735.png)]

数组边界

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TjVS84ch-1626170137967)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210712222126190.png)]

数组的使用

public class Demo14 {
    public static void main(String[] args) {
        int[] arrays = {1, 23, 34, 54};
//
        System.out.println("======遍历数组==========");
        for (int i = 0; i < arrays.length; i++) {
            System.out.println(arrays[i]);
        }
        System.out.println("======计算数数组sum==========");
        int sum = 0;
        for (int i = 0; i < arrays.length; i++) {

            sum = sum + arrays[i];
        }
        System.out.println(sum);
        System.out.println("=======找最大数=========");
        int max=arrays[0];
        for (int i = 1; i < arrays.length; i++){
            if (arrays[i]>max){
                max=arrays[i];
            }
        }
        System.out.println(max);

    }


    //   打印数组
    public static void printArray (int[] arrays ){
for (int i = 0; i < arrays.length; i++) {
        System.out.print(arrays[i]+"");
    }
}

}

多维数组

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZZGdbxKS-1626170137967)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210713082652167.png)]

public class Demo15 {
    public static void main(String[] args) {
        int[][] array = {{1,2},{2,3},{3,4},{4,5}};



//        printArray(array[0]);
        System.out.println(array[0][0]);
        System.out.println(array[0][1]);
    }
//   打印数组
    public static void printArray (int[] arrays ){
for (int i = 0; i < arrays.length; i++) {
        System.out.print(arrays[i]+"");
    }
}

}

Arrays类

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Qk5zHNMb-1626170137968)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210713093634484.png)]

  //        打印数组Arrays.toString方法     
int [] arr={1,2,4,2,33,4,567,};
        System.out.println(arr);    public static void main(String[] args) {
        int [] arr={221,244,44,2,33,4,567,};
        System.out.println(arr);
//        打印数组Arrays.toString方法
        System.out.println(Arrays.toString(arr));
//数组排序（升序）
        Arrays.sort(arr);
        System.out.println(Arrays.toString(arr));
//        数组填充
        Arrays.fill(arr,2,4,88);
//        从下标2开始填充到下标4（不包括4下标）
        System.out.println(Arrays.toString(arr));
    }
//        打印数组Arrays.toString方法
        System.out.println(Arrays.toString(arr));

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p6RBLaKB-1626170137969)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210713100557450.png)]

冒泡排序

1、比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置

2、每一次比较，都会产生出一个最大,或者最小的数字;
3、下一轮则可以少一次排序!
4、依次循环,直到结束!

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fa8JMaCP-1626170137969)(C:\Users\hello\Desktop\冒泡排序.gif)]

import java.util.Arrays;

public class Demo17 {
    public static void main(String[] args) {
int []a={1,23,1,23,132,32,321,232,32324,5354,646,57,654,756,7,6578,658,76,89,769,87,987,9,78};
        int[] sort = sort(a);//调用完我们自己写的排序方法以后，返回一个排序后的数组
        System.out.println(Arrays.toString(sort));

    }


//1、比较数组中，两个相邻的元素，如果第一个数比第二个数大，我们就交换他们的位置
//2、每一次比较，都会产生出一个最大,或者最小的数字;
//3、下一轮则可以少一次排序!
// 4、依次循环,直到结束!

    public static int [] sort(int[] array) {
        int temp = 0;
//        外层循环判断我循环多少次
        for (int i = 0; i < array.length - 1; i++) {

//内层循环，比较判断两个数，如果第一大于第二个，则交换位子，
            for (int j = 0; j < array.length - 1 - i; j++){
         if (array[j+1]<array[j]){   //小到大排序
             temp=array[j];
             array[j]=array[j+1];
             array[j+1]=temp;

                  }

            }
        }
        return array;
    }
}

稀疏数组

稀疏数组介绍

当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。稀疏数组的处理方式是:
记录数组一共有几行几列，有多少个不同值
把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模如下图:左边是原始数组，右边是稀疏数组

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-CbDbj3Ly-1626170137970)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210713105923182.png)]

例子

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LrpJHd21-1626170137970)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210713104849787.png)]

import java.util.Arrays;

public class Demo18 {
    public static void main(String[] args) {
//        创建一个二维数组11*11,0表示没有棋子，1表示黑棋子。2表示白棋子
        int[][] array = new int[11][11];
        array[1][2] = 1;
        array[2][3] = 2;
//        输出原始的数组
        System.out.println(" 输出原始的数组");
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                System.out.print(array[i][j] + "  ");
            }
            System.out.println();
        }
        System.out.println("======================");
//        转换为稀疏数组保存
//        获取有效的数据个数sum
        int sum = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != 0) {
                    sum++;
                }
            }
        }
        System.out.println("有效的数据个数sum:" + sum);

//        2.创建一个稀疏数组的数组
        int[][] array2 = new int[sum + 1][3];
        array2[0][0] = 11;
        array2[0][1] = 11;
        array2[0][2] = sum;
//3.遍历二维数组，将非零值存放在稀疏数组中
        int count = 0;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array[i].length; j++) {
                if (array[i][j] != 0) {
                    count++;
                    array2[count][0] = i;
                    array2[count][1] = j;
                    array2[count][2] = array[i][j];
                }
            }

        }
//        输出稀疏数组
        System.out.println("稀疏数组");
        for (int i = 0; i < array2.length; i++) {
            System.out.println(array2[i][0] + "\t"
                    + array2[i][1] + "\t"
                    + array2[i][2] + "\t");

        }
        System.out.println("==========还原============");
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //2.给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2];
        }
//3.打印
        System.out.println("还原的数组");
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println();
        }

    }

}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bKdJ8cTJ-1626170137971)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210713144244766.png)]

运行结果

 输出原始的数组
0  0  0  0  0  0  0  0  0  0  0  
0  0  1  0  0  0  0  0  0  0  0  
0  0  0  2  0  0  0  0  0  0  0  
0  0  0  0  0  0  0  0  0  0  0  
0  0  0  0  0  0  0  0  0  0  0  
0  0  0  0  0  0  0  0  0  0  0  
0  0  0  0  0  0  0  0  0  0  0  
0  0  0  0  0  0  0  0  0  0  0  
0  0  0  0  0  0  0  0  0  0  0  
0  0  0  0  0  0  0  0  0  0  0  
0  0  0  0  0  0  0  0  0  0  0  
======================
有效的数据个数sum:2
稀疏数组
11	11	2	
1	2	1	
2	3	2	
==========还原============
还原的数组
0	0	0	0	0	0	0	0	0	0	0	
0	0	1	0	0	0	0	0	0	0	0	
0	0	0	2	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	
0	0	0	0	0	0	0	0	0	0	0	

Process finished with exit code 0

面向对象（OOP）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-uY75SGfn-1626170137971)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210713150058839.png)]

什么是面向对象

面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tUDMU6Bl-1626170137972)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210713151751591.png)]

面向过程&面向对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-icfBcoIS-1626170137972)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210713151919215.png)]

方法

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VPsVzI2o-1626170137973)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210713162025158.png)]

值传递

package oop;
//java值传递
public class Demo2 {
    public static void main(String[] args) {
        int a=1;
        System.out.println(a);
        Demo2.change(a);
        System.out.println(a);
    }

    public static void change(int a){
        a=10;

    }
}

引用传递

package oop;

public class Demo3 {
    public static void main(String[] args) {
        People people=new People();
        System.out.println(people.name);
        Demo3.change(people);
        System.out.println(people.name);

    }


    public static void change(People people){
        people.name="王八";
    }
}
//定义一个people类，有一个name属性
class People{
    String name ;
}

类于对象的关系

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V4tInq6N-1626170137974)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210713162537664.png)]

创建与初始化对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oJFKynkZ-1626170137974)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210713164451469.png)]

egg

package oop;

public class Application {
    public static void main(String[] args) {
//类：抽象的，实例化类
//        类实例化会返回一个自己的对象
//        student对象就是Student类的具体实例
        Student xiaohua  = new Student();
        xiaohua.age=17;
        System.out.println(xiaohua.name);
        System.out.println(xiaohua.age);
    }
}

package oop;
//学生类
public class Student {

//    属性：字段
    String name;
    int age;
//    方法
    public void study(){
        System.out.println(this.name+"在学习");

    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pjlxPMen-1626170137975)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210713165934718.png)]

构造器

// 快捷键生成有参无参构造器 Alt+insert

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-o9zlYRsa-1626170137976)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210713173050390.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-BqqDMxen-1626170137977)(C:\Users\hello\AppData\Roaming\Typora\typora-user-images\image-20210713173225965.png)]

package oop;

public class Person {
    String name;

//  实例化初始值
//    使用new关键字，本质是在调用构造器
//    用来初始化值
//    无参构造
    public Person(){
        this.name="apple";
    }
//    有参构造:一旦定义了有参构造，无参构造就必须显示定义
    public Person(String name){
        this.name=name;
    }

//    快捷键生成有参无参构造器 Alt+insert
    /*
     public class Application {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);
    }
}
构造器:
1．和类名相同
2．没有返回值
作用:
1. new本质在调用构造方法
2．初始化对象的值
注意点:
1．定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造

     */

}

String name;
int age;

// 方法
public void study(){
System.out.println(this.name+“在学习”);

}








[外链图片转存中...(img-pjlxPMen-1626170137975)]

## 构造器

//    快捷键生成有参无参构造器 Alt+insert

[外链图片转存中...(img-o9zlYRsa-1626170137976)]



[外链图片转存中...(img-BqqDMxen-1626170137977)]

```java
package oop;

public class Person {
    String name;

//  实例化初始值
//    使用new关键字，本质是在调用构造器
//    用来初始化值
//    无参构造
    public Person(){
        this.name="apple";
    }
//    有参构造:一旦定义了有参构造，无参构造就必须显示定义
    public Person(String name){
        this.name=name;
    }

//    快捷键生成有参无参构造器 Alt+insert
    /*
     public class Application {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);
    }
}
构造器:
1．和类名相同
2．没有返回值
作用:
1. new本质在调用构造方法
2．初始化对象的值
注意点:
1．定义有参构造之后，如果想使用无参构造，显示的定义一个无参的构造

     */

}

hello蜗牛

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
JavaSE基础

一、java基础再次学习java三大版本Write Once、Run AnywhereJavaSE:标准版(桌面程序,控制台开发…….)JavaME:嵌入式开发(手机,小家电…)JavaEE: E企业级开发(web端，服务器开发…)标识符关键字：（不能用于命名）[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sbPxrml6-1626170137951)(C:\Users\hello\AppData\Roaming\Typora\typora-user-imag
复制链接

扫一扫