先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7
深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！
由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新
如果你需要这些资料，可以添加V获取：vip1024b （备注Java）
正文
/* ‘a’ – 97
‘A’ – 65
‘o’ – 48
*/
3.字符串的"+"操作
pubic class Demo {
public static void main(String[] args) {
// 当 + 操作出现字符串时，这个 + 是[字符串连接符]，而不是算数运算
// 字符串可以使用 + 号，跟[任意数据类型]拼接
System.out.println(“ItHeiMa” + 666);
// ItHeiMa666
System.out.println(1 + 99 + “年”);
// 100年
System.out.println(“5 + 5” + 5 + 5 )
// 5 + 555
}
}
4.案例：数值拆分
import java.util.Scanner;
public class Demo{
public static void main(String[] args){
// 1.使用Scanner 键盘录入一个三位数
Scanner sc = new Scanner(System.in);
System.out…println(“请输入一个三位数:”);
int num = sc.nextInt();
// 2.个位的计算: 数值 % 10
int ge = num % 10;
// 3.十位的计算: 数值 / 10 % 10
int shi = num / 10 % 10;
// 4.百位的计算: 数值 / 100
int bai = num / 100;
System.out.println(“整数”+num+“的个位为:”+ge);
System.out.println(“整数”+num+“的十位为:”+shi);
System.out.println(“整数”+num+“的百位为:”+bai);
}
}
公式总结:
个位: 数值 % 10
十位: 数值 / 10 % 10
百位: 数值 / 10 / 10 % 10
千位: 数值 / 10 / 10 / 10 % 10
5.自增自减运算符
| 符号 | 作用 | 说明 |
| — | — | — |
| ++ | 自增 | 变量的值加1 |
| – | 自减 | 变量的值减1 |
-
++ 和 --可以放在变量的后边，也可以放在变量的前面
-
单独使用的时候，++ 和 – 无论放在变量的前边和后边，结果是一样的
public class Demo {
public static void main(String[] args){
int a = 10;
// ++在前，先对该变量做自增或自减,然后再拿变量参与操作
int a = 10;
int b = ++a;
System.out.println(a); // 11
System.out.println(b); // 11
// ++在后 先将该变量原本的值，取出来参与操作，随后再自增
int aa = 10;
int bb = aa++;
System.out.println(aa); // 11
System.out.println(bb); // 10
int num = 123;
System.out.println(num++); // 123
}
}
4.赋值运算符
| 符号 | 作用 | 说明 |
| — | — | — |
| = | 赋值 | a = 10,将10赋值给变量a |
| += | 加后赋值 | a + = b，将 a + b 的值给a |
| - = | 减后赋值 | a - = b，将 a - b的值给a |
| * = | 乘后赋值 | a * = b，将a × b 的值给a |
| / = | 除后赋值 | a / = b，将a ÷ b 的商给a |
| % = | 取余后赋值 | a % = b，将a ÷b 的余数给a |
10.关系运算符
| 符号 | 说明 |
| — | — |
| = = | a = =b，判断a 和 b的值是否相等 |
| ! = | |
| > | |
| > = | |
| < | |
| < = | |
11.逻辑运算符
| & | 与 |
| — | — |
| | | 或 |
| ！ | 非（取反） |
| ^ | 异或(相同为false,不同为true) |
public class Demo {
public static void main(String[] args){
System.out.println(true ^ true); // false
System.out.println(false ^ false); // false
System.out.println(true ^ false); // true
System.out.println(false ^ true); // true
/* 两边一样就是false，不一样即为true */
}
}
12.短路逻辑运算符
| 符号 | 作用 | 说明 |
| — | — | — |
| && | 短路与 | 作用与&相同，但是有短路效果 |
| || | 短路或 | 作用与|相同，但是有短路效果 |
public class Demo {
public static void main(String[] args){
/*
& 和 && 的区别:
& :无论符号左边是 true 还是 false,右边都要继续执行
&& :具有短路效果，符号左边为false的时候，右边就不执行
如果符号左边为true，右边要继续执行
*/
int x = 3;
int y = 4;
// false & true
System.out.println(++x > 4 & y-- < 5); //false
System.out.println(“x=” + x); // 4
System.out.println(“y=” + y); // 3
int x = 3;
int y = 4;
// false && true
System.out.println(++x > 4 & y-- < 5); //false
System.out.println(“x=” + x); // 4
System.out.println(“y=” + y); // 4
}
}
注意事项:
1.逻辑与 &：无论左边真假，右边都要执行
2.短路与 &&：如果左边为真，右边执行，如果左边为假，右边不执行
3.逻辑或 | ： 无论左边真假，右边都要执行
4.短语或 ||：颗左边为假，右边执行，如果左边为真，右边不执行
13.三元运算符
关系表达式 ? 表达式1 : 表达式2
14.案例：三个和尚
public class Demo{
public static void main(String[] args){
// 1.定义三个变量用于保存和尚的身高
int a = 150;
int b = 210;
int c = 165;
// 2.用三元运算符，比较前两个变量，获取较大值
int temp = a > b ? a : b;
// 3.用三元运算符，比较较大值和第三个变量
int Max = temp > c ? temp : c;
System.out.println(Max);
}
}
1.if
import java.util.Scanner;
public class Demo{
public static void main(String[] args){
Scanner score = new Scanner(System.in);
System.out.println(“请输入您的考试成绩:”);
int score = sc.nextInt();
if(score >= 0 && score <= 100){
if(score >= 95 && score <= 100){
System.out.println(“666”);
}else if(score >= 90 && score <= 94){
System.out.println(“66”);
}else if(score >= 80 && score <= 89){
System.out.println(“6”);
}else{
System.out.println(“挨顿揍！”);
}
}else{
System.out.println(“您的成绩输入有误”);
}
}
}
2.switch
switch(表达式) {
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
default:
语句体3;
break;
}
1.案例:减肥计划
import java.util.Scanner;
public class Demo{
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
System.out.println(“今天是周几:”);
int week = sc.nextInt();
switch(week){
case 1:
System.out.println(“”);
break;
case 2:
System.out.println(“”);
break;
case 2:
System.out.println(“”);
break;
default:
System.out.println(“您的输入有误”);
break;
}
}
}
3.case穿透
如果switch语句中，case省略了break语句，就会开始case穿透
现象:当开始case穿透，后序的case就不会具有匹配效果，内部的语句都会执行
直到看到break,或者将整体switch语句执行完毕，才会结束
4.for
for(初始化语句;条件判断语句;条件控制语句){
循环体语句;
}
1.案例：输出数据
public class Demo{
public static void main(String[] args){
for(int i = 1; i <= 5;i++){
System.out.println(i);
}
for(int i = 5; i >= 1; i–){
System.out.println(i);
}
}
}
2.案例:求1-5数据和
int sum = 0;
for(int i = 1;i <= 5;i++){
sum += i;
}
System.out.println(sum);
3.案例:求1-100偶数和
int sum = 0;
for(int i = 1; i <= 100;i++){
if(i % 2 == 0){
sum += i;
}
}
System.out.println(sum);
4.案例:逢7过
for(int i = 1; i <= 100;i++){
int ge = i % 10;
int shi =i / 10 % 10;
if(ge == 7 || shi == 7 || i % 7 == 0){
System.out.println(i);
}
}
5.案例：水仙花数
for(int i = 100; i <= 999; i++){
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 10 / 10 % 10;
if(gegege + shishishi + baibaibai == i){
System.out.println(i);
}
}
6.每行打印两个水仙花
int count = 0;
for(int i = 100; i <= 999; i++){
int ge = i % 10;
int shi = i / 10 % 10;
int bai = i / 10 / 10 % 10;
if(gegege + shishishi + baibaibai == i){
System.out.print(i + " ");
count++;
if(count % 2 == 0){
System.out.println();
}
}
}
5.while
初始化语句;
while(条件判断语句){
循环体语句;
条件控制语句;
}
1.案例:珠穆朗玛峰
public class Demo{
/*
需求：世界最高山峰是珠穆朗玛峰(8844.43米=8844430毫米)，假如我有一张足够大的纸，它的厚度是0.1毫米。
请问，我折叠多少次，可以折成珠穆朗玛峰的高度?
*/
public static void main(String[] args){
// 1.定义计数器变量，准备用于统计折叠的次数
int count = 0;
// 2.准备纸张厚度变量,珠峰高度变量
double paper = 0.1;
int zf = 8844430;
// 3.不确定循环次数，使用while循环
while(paper <= zf){
paper *= 2;
System.out.println(paper);
// 每折叠一次,计数器就要自增
count++;
}
System.out.println(count);
}
}
6.dowhile
初始化语句;
do{
循环体语句;
条件控制语句;
}while(条件判断语句);
8.死循环
1.for死循环
public class Demo{
public static void main(String[] args){
// for死循环格式
for(;😉{
System.out.println(“我停不下来了”);
}
}
}
2.while死循环
public class Demo{
public static void main(String[] args){
while(true){
System.out.println(“我停不下来了”);
}
}
}
3.dowhile死循环
public class Demo{
public static void main(String[] args){
do{
System.out.println(“我停不下来了”);
}while(true);
}
}
命令提示符窗口中 Ctrl+C 可以结束死循环
9.continue
作用: 跳过某次循环体内容的执行
public class Demo{
public static void main(String[] args){
// 模拟电梯上升，1-24层，4层不停
for(int i = 1;i <= 24 ;i++){
if(i == 4){
continue;
}
System.out.println(i + “层到了~”);
}
}
}
10.break
作用:终止循环体内容的执行
public class Demo {
public static void main(String[] args){
// 模拟20岁工作到80岁，60岁退休
for(int i = 20; i <= 80; i++){
if(i == 60){
break; //结束整个循环
}
System.out.println(i + “岁正在上班”);
}
}
}
1.案例:减肥计划改进
import java.util.Scanner;
public class Test {
/*
需求：程序运行后，用户可多次查询星期对应的减肥计划，直到输入0，程序结束
步骤:
-
不明确用户操作几次, 使用死循环包裹业务逻辑
-
匹配到0的时候，使用break结束循环死循环
*/
public static void main (String[] args){
lo:while(true){
System.out.println(“请输入您要查看的星期数:”);
System.out.println(“(如无需继续查看,请输入0退出程序)”);
// 1. 键盘录入星期数据，使用变量接收
Scanner sc = new Scanner(System.in);
int week = sc.nextInt();
// 2. 多情况判断，采用switch语句实现
switch(week){
// 3. 在不同的case中，输出对应的减肥计划
case 0:
System.out.println(“感谢您的使用”);
break lo;
case 1:
System.out.println(“跑步”);
break;
case 2:
System.out.println(“游泳”);
break;
case 3:
System.out.println(“慢走”);
break;
case 4:
System.out.println(“动感单车”);
break;
case 5:
System.out.println(“拳击”);
break;
case 6:
System.out.println(“爬山”);
break;
case 7:
System.out.println(“好好吃一顿”);
break;
default:
System.out.println(“您的输入有误”);
break;
}
}
}
}
作用:用于产生一个随机数
1.导包
import java.util.Random
public class Demo{
/*
Random:产生随机数
1.导包: import java.util.Random;
2.创建对象: Random r = new Random();
r 是变量名,可以变，其他的都不允许改变
3.获取随机数: int numeber = r.nextInt(10);
获取数据的范围:[0,10)，包括0，不包括10
number 是变量名，可以变，数字10可以变，其他的不允许变
public static void main(String[] args){
*/
2.创建对象
Random r = new Random();
3.获取随机数
int num = r.nextInt(num);
}
1.案例:猜数字
import java.util.Scanner;
import java.util.Random;
public static void main(String[] args){
// 1.准备 Random 和Scanner对象，分别用于产生随机数和键盘录入
Random r = new Random();
Scanner sc = new Scanner(System.in);
// 2.使用Random 产生一个1-100之间的数，作为要猜的数
int randomNum = r.nextInt(100) + 1;
while(true){
// 3.键盘录入用户猜的数据
System.out.println(“请输入您猜的数:”);
int num = sc.nextInt();
// 4.进行比较
if(num > randomNum){
System.out.println(“猜大了”);
}else if(num < randomNum){
System.out.println(“猜小了”)
}else{
System.out.println(“猜中了！”);
break;
}
}
}
======================================================================
// 格式一:数据类型[] 变量名
int[] array;
// 格式二:数据类型 变量名[]
int array[];
// 定义了一个int类型的数组，数组名叫arr
int[] arr;
System.out.prinln(arr[])
格式: 数据类型[]变量名 = new 数据类型[数组长度];
int[] arr = new int[3];
System.out.println(arr[0]); // 0 系统自动分配的默认初始值
格式一: 数据类型[] 变量名 = new 数据类型[]{数据1，数据2，数据3,…}
int[] arr = new int[]{1,2,3};
简化格式: 数据类型[] 变量名 = {数据1，数据2，数据3，…}
int[] arr = {1,2,3};
动态初始化: 手动指定数组长度，由系统给出默认初始化值
静态初始化: 手动指定数组元素，系统会根据元素个数，计算出数组的长度
// 动态获取数组元素个数: 数组名.length
int[] arr= {11,22,33,44,55};
for(int i = 0;i < arr.length; i++ ){
System.out.println(arr[i]);
}
/*
1.假设数组中的第一个元素为最大值
2.遍历数组，获取每一个元素，准备进行比较
3.如果比较的过程，出现了比max更大的，让max记录更大的值
4.循环结束后，打印最大值
*/
public static void main(String[] args){
int[] arr = {12,45,98,73,60};
int max = arr[0];
for(int i = 1; i < arr.length;i++){
if(arr[i] > max){
max = arr[i];
}
}
System.out.println(“max” + max);
}
======================================================================
1.方法定义
public static void 方法名(){
//方法体
}
public static void eat(){
//方法体
}
2.方法调用
方法名();
eat();
注意:1.方法必须先定义后调用
2.方法与方法之间是平级关系，不能嵌套定义
3.方法没有被调用的时候，都在方法区中的字节码文件(.class)中存储
4.方法被调用的时候，需要进入到栈内存中运行
3.奇偶数判断
public class Demo{
public static void main(String[] args){
// 3. main 方法中调用method
method();
}
// 1.定义method方法
public static void method(){
// 2.方法中定义变量,使用if语句判断是奇数还是偶数
int num = 10;
if(num % 2 ==0){
System.out.println(“偶数”);
}else{
System.out.println(“奇数”);
}
}
}
4.带参数的方法
public static void 方法名(数据类型变量名1,数据类型变量名2,…){.}
public static void getMax(int number1,int number2){…}
方法名(参数);
方法名(变量名1/常量值1,变量名2,常量值2);
getMax(5,6);
public class Demo1 {
public static void main(String[] args){
IsEvenNumber(10);
}
public static void IsEvenNumber(int num){
if(num % 2 == 0){
System.out.println(“是偶数”);
}else{
System.out.println(“是奇数”);
}
}
}
1.案例 :打印n-m所有的奇数
public class Demo{
public static void main(String[] args){
print(10,20);
}
// 1.定义方法，方法名为print
// 2.方法中添加两个int类型的形参
public static void print(int n,int m){
System.out.println(n + “到” + m + “之间的奇数为”);
for(int i = n; i <= m;i++){
if(i % 2 == 1){
System.out.println(i);
}
}
}
}
5.带返回值方法
1.定义
public static 数据类型 方法名(参数){
return 数据;
}
public static boolean isEvenNumber(int number){
return true;
}
public static int getMax(int a,int b){
return 100;
}
注意: 方法定义时 return 后面的返回值与方法定义上的数据类型要匹配，否则程序将报错
2.调用
格式一: 方法名(参数);
isEvenNumber(5);
格式二: 数据类型 变量名 = 方法名(参数);
boolean flag = isEvenNumber(5);
public static void main(String[] args){
// 需求: 定义一个方法，计算两个整数相加的和
int num = add(10, 10);
System.out.println(num);
}
public static int add(int a, int b){
int c = a + b;
return c;
}
3.案例
设计一个方法可以获取两个数的较大值，数据来自于参数
public class Demo{
public static void main(String[] args){
int result = getMax(10,20);
System.out.println(result);
}
public static int getMax(int a, int b){
if(a > b){
return a;
}else{
return b;
}
}
}
6.方法的通用格式
public static 返回值类型 方法名(参数){
方法体;
return 数据;
}
7.方法的注意事项
1.方法不能嵌套定义
2.方法的返回值类型为 void ，表示该方法没有返回值,没有返回值的方法可以省略 return 语句不写。如果要编写return，后面不能跟具体的数据，执行不到，属于无效的代码
3.return 语句下面，不能编写代码，因为永远执行不到，属于无效的代码
8.方法重载
简单记:同一个类中，方法名相同，参数不同的方法
参数不同: 个数不同，类型不同，顺序不同
注意
识别方法之间是否是重载关系，只看方法名和参数，跟返回值无关
1.案例:重载练习
// 需求:使用方法重载的思想，设计比较两个整数是否相同的方法，兼容全整数类型()
public class Demo{
public static void main(String[] args){
int a = 10;
int b = 20;
System.out.println(compare(a,b));
}
public static boolean compare(int a,int b){
return a == b;
}
public static boolean compare(byte a,byte b){
return a == b;
}
public static boolean compare(short a,short b){
return a == b;
}
public static boolean compare(long a,long b){
return a == b;
}
}
9.方法参数传递
1.方法参数传递(基本类型)
public class Demo{
public static void main(String[] args){
int number = 100;
System.out.println(“调用change方法前:” + number);
// 100
change(number);
System.out.println(“调用change方法后:” + number);
// 100
}
}
2.方法参数传递(引用类型)
public class Demo{
/*
方法参数传递为引用数据类型:传入方法中的，是内存地址
*/
public static void main(String[] args){
int[] arr = {10,20,30};
System.out.println(“调用change方法前:” + arr[1]);
// 20
change(arr);
System.out.println(“调用change方法后:” + arr[1]);
// 200
}
public static void change(int[] arr){
arr[1] = 200;
}
}
3.案例:数组遍历
public class Demo{
public static void main(String[] args){
int[] arr = {11,22,33,44,55};
printArray(arr);
}
// 定义一个方法，对数组进行遍历
// 1.参数: int[] arr
// 2.返回值类型: void
System.out.print(“[”);
public static void printArray(int[] arr){
for(int i = 1; i <= arr.length; i++){
if(i == arr.length - 1){
//最大索引 = 数组长度 - 1
System.out.println(arr[i] + “]”);
}else
{
System.out.print(arr[i] + “,”);
}
}
}
}
4.案例:获取数组最大值
public class Demo{
public static void main(String[] args){
// 1.定义一个数组
int[] arr ={11,22,55,44,33};
int max = getMax(arr);
System.out.println(max);
}
// 2.定义一个方法，用来获取数组中的最大值
// 2.1 参数 int[] arr
// 2.2 返回值类型 int
public static int getMax(int[] arr){
int max = arr[0];
for(int i = 1; i <= arr.length;i++){
if(max < arr[i]){
max = arr[i];
}
}
return max;
}
}
5.案例:获取数组最大值和最小值
public static void main(String[] args){
int[] arr = {11,55,22,33,44};
int[] maxAndMin = getMaxAndMin(arr);
}
// 返回值类型:数组类型 int[]
public static int[] getMaxAndMin(int[] arr){
int max = arr[0];
for(int i = 1; i <= arr.length;i++){
if(max < arr[i]){
max = arr[i];
}
}
int min = arr[0];
for(int i = 1; i <= arr.length;i++){
if(min > arr[i]){
min = arr[i];
}
}
int[] maxAndMin = {max,min};
return maxAndMin;
}
========================================================================
格式一 :数据类型[][] 变量名;
int[][] arr;
格式二 :数据类型 变量名[][];
int arr[][];
格式三 :数据类型[] 变量名[];
int[] arr[];
格式: 数据类型[][] 变量名 = new 数据类型[m][n];
m 表示这个二维数组，可以存放多少个一维数组
n 表示每一个一维数组，可以存放多少个元素
int[][] arr = new int[2][3];
// 该数组可以存放 2 个 一维数组，每个一维数组中可以存放 3 个 int 类型元素
public class Demo{
public static void main(String[] args){
/*
问题:二维数组中存储的是一维数组，那能不能存入[提前创建好的一维数组]呢？
*/
int[] arr1 = {11,22,33};
int[] arr2 = {44,55,66};
int[] arr3 = {77,88,99,100};
int[][] arr = new int[3][3];
arr[0] = arr1;
arr[1] = arr2;
arr[2] = arr3;
System.out.println(arr[1][2]);
// 66
System.out.println(arr[2][3]);
// 100
}
}
// 格式: 数据类型[][] 变量名 = new 数据类型[][] {{元素1，元素2…},{元素1,元素2…}};
int[][] arr = new int[][]{{11,22},{33,44}};
// 简化格式
数据类型[][] 变量名 ={{元素1,元素2},{元素1,元素2…}};
int[][] arr ={{11,22},{33,44}};
public class Demo{
/*
需求:已知一个二维数组 arr = {{11,22,33},{44,55,66}}
遍历该数组，取出所有元素并打印
*/
public static void main(String[] args){
int[][] arr = {{11,22,33},{44,55,66}};
// 遍历二维数组，取出里面每一个一维数组
for(int i = 0;i < arr.length;i++){
// 遍历一维数组,arr[i]就是每一个一维数组
for(int j = 0;j < arr[i].length;j++){
System.out.println(arr[i][j]);
}
}
}
}
public static void main(String[] args){
// 1.定义求和变量
int sum = 0;
int[][] arr = {{11,22,33},{44,55,66},{77,88,99}};
// 2.遍历二维数组，获取所有元素
for(int i = 0;i < arr.length;i++){
for(int j = 0;i < arr[i].length;j++){
sum += arr[i][j];
}
}
System.out.println(sum);
}
==========================================================================
类的组成: 属性 和 行为
1.属性: 在代码中通过成员变量来体现(类中方法外的变量)
2.行为: 在代码中通过成员方法来体现(和前面的方法相比，去掉static关键字即可)
public class 类名{
// 成员变量
变量1的数据类型 变量1;
变量2的数据类型 变量2;
…
// 成员方法
方法1;
方法2;
…
}
public class Student{
// 属性: 姓名,年龄
// 成员变量:跟之前定义变量的格式一样，只不过位置发生了改变，类中方法外
String name;
int age;
// 在不在Student 类中 ? 在
// 在不在方法外? 在，因为Student 类中没有方法
// 行为: 学习
// 成员方法:跟之前定义方法的格式一样，只不过去掉了static关键字
public void study(){
System.out.println(“学习”);
}
}
创建对象
// 格式: 类名 对象名 = new 类名();
// Student s = new Student();
使用对象
// 1.使用成员变量
// 格式: 对象名.变量名
s.name
// 2.使用成员方法
// 格式： 对象名.方法名()
s.study();
public class TestStudent {
/*
创建对象的格式:
类名 对象名 = new 类名();
调用成员变量的格式:
对象名.变量名
调用成员方法的格式:
对象名.方法名();
*/
public static void main(String[] args){
// 1.创建对象
Student stu = new Student();
// 2.调用成员变量
stu.name = “张三”;
stu.age = 23;
// 3.调用成员方法
stu.study();
}
}
1.案例:手机类
public class Phone {
// 品牌，价格
String brand;
int price;
// 打电话 发短信
public void call(String name){
Sout(“给” + name + “打电话”);
}
public void sendMessage(){
Sout(“群发短信”);
}
}
public class TestPhone {
public static void main(Sring[] args){
Phone p = new Phone();
p.brand = “iPhone12”;
p.price = 7000;
p.call();
}
}
区别:
1.private关键字
private是一个权限修饰符,可以用来修饰成员(变量，方法)
特点:被private修饰的成员只能在本类中才能访问
public class Student {
private int age;
// 设置值
public void setAge(int a){
if(a >= 0 && a <= 120){
age = a;
}else {
System.out.println(“您输入的年龄不合理”);
}
}
// 获取值
public void getAge(){
return age;
}
}
public class TestStudent {
public static void main(String[] args){
Student stu = new Student();
stu.setAge(23);
}
}
2.private关键字的使用
public class Student {
private String name;
private int age;
//设置姓名值
public void setName(String n){
name = n;
}
//获取姓名值
public String getName(){
return name;
}
//设置年龄值
public void setAge(int a){
age = a;
}
//获取年龄值
public int getAge(){
return age;
}
public void show(){
System.out.println(name + “…” + age);
}
}
右键-new-Java Class
public class TestStudent {
public static void main(String[] args){
Student stu = new Student();
stu.setName(“张三”);
stud.setAge(23);
System.out.println(stu.getName());
System.out.println(stu.getAge());
}
}
3.this 关键字
4.封装
构造方法:构建、创建对象的时候，所调用的方法
格式:
1.方法名与类名相同,大小写也要一致
2.没有返回值类型，连void都没有
3.没有具体的返回值(不能由return带回结果数据)
public class Student { // 类
public Student(){ // 构造方法
System.out.println(“我是Student类的构造方法”);
}
}
// 调用方法
public class TestStudent {
public static void main(String[] args){
Student stu = new Student();
// 我是Student类的构造方法
}
}
// 执行时机
// 1.创建对象的时候调用，每创建一次对象，就会执行一次构造方法
// 2.不能手动调用构造方法
stu.Student(); // 报错
1.StringBuilder
| 方法名 | 说明 |
| — | — |
| public StringBuilder() | 创建一个空白可变字符串对象，不含有任何内容 |
| public StringBuilder(String str) | 根据字符串的内容，来创建可变字符串对象 |
public class Demo {
public static void main(Srting[] args){
// public StringBuilder():创建一个空白可变字符串对象，不含有任何内容
StringBuilder sb = new StringBuilder();
System.out.println(sb); // 打印出来是空白
// public StringBuilder(String str): 根据字符串的内容，来创建可变字符串对象
StringBuilder sb2 = new StringBuilder(“abc”);
System.out.println(sb); // 打印出来 abc
}
}
2.注意事项
一.构造方法的创建
1.如果没有定义构造方法，系统将给出一个默认的无参数构造方法
2.如果定义了构造方法，系统将不再提供默认的构造方法
解决方法：
无论是否使用，都手动书写无参数构造方法，和带参数构造方法
/*
javaBean类: 封装数据
*/
public class Student {
// 两个成员变量 私有
private String name;
private int age;
// 无参数构造方法
public Student(){
}
// 有参数构造方法
public Student(String name,int age){
this.name = name;
this.age = age;
}
// 成员方法: setXX \ gerXX
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age
}
public int getAge(){
return age;
}
public void show(){
System.out.print;n(name + “…” + age);
}
}
快捷键方法
只需要写一个类
在写私有方法即可
public class Student{
private String name;
private int age;
}
无参构造方法 鼠标右键-Generate-Constructor-SelectNone
有参构造方法 鼠标右键-Generate-Constructor-Ctrl+A-OK
setXX\getXX 鼠标右键-Generate-Getter and Setter -Ctrl+A-OK
2.测试，新建一个类，需要有主函数
public class TestStudent{
public static void main(String[] args){
// 1. 无参数构造方法创建对象，通过setXX方法给成员变量进行赋值
Student stu1 = new Student();
stu1.setName(“张三”);
stu1.setAge(23);
stu1.show();
// 2.通过带参数构造方法，直接给属性进行赋值
Student stu2 = new Student(“李四”,24);
stu2.show();
}
}
========================================================================
API: Application Programming Interface 应用程序编程接口
public class Demo{
/*
next(): 遇到了空格，就不再录入数据
结束标记:空格，tab键
nextLine(): 可以将数据完整的接收过来
结束标记:回车换行符
*/
public static void main(String[] args){
// 1.创建Scanner对象
Scanner sc = new Scanner(System.in);
System.out.println(“请输入:”);
// 2.调用nextLine 方法接收字符串
// ctrl + alt + v :快速生成方法的返回值
String s = sc.nextLine();
System.out.println(s);
}
}
public java.util.Scanner;
最后
笔者已经把面试题和答案整理成了面试专题文档
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
c class Demo {
public static void main(Srting[] args){
// public StringBuilder():创建一个空白可变字符串对象，不含有任何内容
StringBuilder sb = new StringBuilder();
System.out.println(sb); // 打印出来是空白
// public StringBuilder(String str): 根据字符串的内容，来创建可变字符串对象
StringBuilder sb2 = new StringBuilder(“abc”);
System.out.println(sb); // 打印出来 abc
}
}
2.注意事项
一.构造方法的创建
1.如果没有定义构造方法，系统将给出一个默认的无参数构造方法
2.如果定义了构造方法，系统将不再提供默认的构造方法
解决方法：
无论是否使用，都手动书写无参数构造方法，和带参数构造方法
/*
javaBean类: 封装数据
*/
public class Student {
// 两个成员变量 私有
private String name;
private int age;
// 无参数构造方法
public Student(){
}
// 有参数构造方法
public Student(String name,int age){
this.name = name;
this.age = age;
}
// 成员方法: setXX \ gerXX
public void setName(String name){
this.name = name;
}
public String getName(){
return name;
}
public void setAge(int age){
this.age = age
}
public int getAge(){
return age;
}
public void show(){
System.out.print;n(name + “…” + age);
}
}
快捷键方法
只需要写一个类
在写私有方法即可
public class Student{
private String name;
private int age;
}
无参构造方法 鼠标右键-Generate-Constructor-SelectNone
有参构造方法 鼠标右键-Generate-Constructor-Ctrl+A-OK
setXX\getXX 鼠标右键-Generate-Getter and Setter -Ctrl+A-OK
2.测试，新建一个类，需要有主函数
public class TestStudent{
public static void main(String[] args){
// 1. 无参数构造方法创建对象，通过setXX方法给成员变量进行赋值
Student stu1 = new Student();
stu1.setName(“张三”);
stu1.setAge(23);
stu1.show();
// 2.通过带参数构造方法，直接给属性进行赋值
Student stu2 = new Student(“李四”,24);
stu2.show();
}
}
========================================================================
API: Application Programming Interface 应用程序编程接口
public class Demo{
/*
next(): 遇到了空格，就不再录入数据
结束标记:空格，tab键
nextLine(): 可以将数据完整的接收过来
结束标记:回车换行符
*/
public static void main(String[] args){
// 1.创建Scanner对象
Scanner sc = new Scanner(System.in);
System.out.println(“请输入:”);
// 2.调用nextLine 方法接收字符串
// ctrl + alt + v :快速生成方法的返回值
String s = sc.nextLine();
System.out.println(s);
}
}
public java.util.Scanner;
最后
笔者已经把面试题和答案整理成了面试专题文档
[外链图片转存中…(img-OPh3kFgB-1713619554392)]
[外链图片转存中…(img-2QPqMxMv-1713619554392)]
[外链图片转存中…(img-inJBKDxY-1713619554393)]
[外链图片转存中…(img-SOXxRBiA-1713619554393)]
[外链图片转存中…(img-xkbdkgMu-1713619554394)]
[外链图片转存中…(img-efSSB9pn-1713619554394)]
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。
需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-Ymkdj4sF-1713619554395)]
一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
