JAVA基础（全）

Blue桃之夭夭

已于 2023-07-18 11:33:19 修改

阅读量120

点赞数

文章标签： java 开发语言

于 2023-07-18 10:43:16 首次发布

本文链接：https://blog.csdn.net/qq_65966646/article/details/131781630

版权

本文介绍了Java编程的基础知识，包括注释的使用、标识符的命名规则、数据类型、变量、类型转换、Scanner类获取用户输入、各种循环结构（for、while、do-while）、方法的定义与使用、面向对象的封装概念以及构造方法。此外，还涉及到了String类和StringBuilder类的运用。

摘要由CSDN通过智能技术生成

1.注释

注释:解释说明代码,给程序员看的,class文件中是没有注释的
单行注释: //只能注释一行文字 ctrl+/
多行注释😕* 可以注释多行文字*/ ctrl+shirt+/
文档注释: /**可以注释多行文字 */

2.标识符

标识符是用户编程时使用的名字，用于给类、方法、变量、常量等命名。 Java中标识符的组成规则：
由字母、数字、下划线“_”、美元符号“ $组成，第一个字符不能是数字。 stu_name stu_age sutSex sut_Sexsut$ Sex
不能使用java中的关键字作为标识符。
标识符对大小写敏感（区分大小写） stuName sutname
Java中标识符的命名约定：建议大家都遵守
小驼峰式命名：变量名、方法名首字母小写，从第二个单词开始每个单词的首字母大写。
大驼峰式命名：类名|接口|枚举|注解每个单词的首字母都大写。另外，标识符的命名最好可以做到见名知意

例如：username、studentNumber

注意:
无论是项目名称,模块名称,包名,类名,变量名,方法名,都不要使用中文
package com.itheima.demo01;
/*
标识符:起名字

*/
public class Demo01 {
public static void main(String[] args) {
String stuName = "小明";
String stuname = "小明";
int stu_age = 18;
double stu$Height = 1.8;
//关键字不能作为标识符
//String public = "唐三";
}
}

3.常量

常量:在程序运行过程中,其值不可以改变
java中常量的分类
1.整数常量 18 19 -10
2.小数常量 3.14 -8.8
3.字符常量
被一对单引号包裹’ ',一对单引号中只能包含一个字符,并且字符不能为空
‘A’ ‘a’ ‘#’ ‘中’ ’ ’ 正确 ‘AB’ ‘10’ ‘’ 错误
4.布尔常量只有两个值 true(真) false(假)
5.字符串常量
被一对双引号包括"“,字符串可以为空字符串”"
“hello” “你好” “123” “”
6.null:空常量,学习数组的时候使用

4.数据类型(背诵下来)

基本数据类型: 4类8种
整数:byte(1个字节) ,short(2个字节),int(4个字节),long(8个字节)
小数:float(4个字节),double(8个字节)
字符:char(2个字节)
布尔:boolean(1个字节)
引用数据类型:
java提供的类:String,Scanner,Random…
数组
集合

5.变量

package com.itheima.demo01;
/*
变量:就是内存中一块存储区域,存储区域中值是可以改变的
定义格式:
数据类型变量名 = 数据值;
*/
public class Demo02Variable {
public static void main(String[] args) {
//定义一个int类型的变量
int a = 10;
//打印变量的值
System.out.println(a);//10

6.类型转换

类型转换:是一个针对值的转换,整数和小数和字符之间可以相互转换
注意:布尔类型和字符串类型不能转换
数据类型从小到大关系(范围):byte<short(char)<int<long<float<double
默认类型转换: 小=直接赋值给=>大
int a = 10;
double d = a;
sout(d);//10.0
int b = ‘B’;
sout(b);//66
强制类型转换: 大=强制转换为=>小
double d = 15.5;
int a = (int)d;
sout(a);//15 损失精度
System.out.println((int)18.8);//18

7.Scanner的基本使用

//变量的值可以改变的
a=20;
a=30;
a=40;
//打印变量的值
System.out.println(a);//40
}
}
/*
Scanner的基本使用:它是引用数据类型的一种,可以帮助我们获取用户键盘输入的数据
三部曲(固定步骤):
1.导包:找到要使用Scanner类(快捷导包)
import java.util.Scanner;
2.定义一个Scanner类型的变量,创建Scanner对象为变量赋值
数据类型变量名 = 创建对象;
Scanner sc = new Scanner(System.in);
3.可以变量名.方法名()调用Scanner类中的方法,帮助我们获取键盘输入的数据
int a = sc.nextInt(); 获取用户键盘输入的整数,遇到回车或者空格结束
double d = sc.nextDouble(); 获取用户键盘输入的小数,遇到回车或者空格结束
String s = sc.next(); 获取用户键盘输入的字符串,遇到回车或者空格结束
*/
package com.itheima.demo03;
import java.util.Scanner;

8.算术运算符

1.+,-,*,/,%(余数) 10%3=1 10%4=2 10%5=0 1%3=1 4%10=4
除法: 10/3=3 整除 10/3.0=3.33333
字符加法
字符在计算机上存储的时候都有一个对应的数字,使用字符进行加法,可以把字符转换为数字
常用: ‘a’:97 ‘A’:65 ‘0’:48 ‘a’+10 = 107
字符串加法:字符串拼接

任意数据类型的数据和字符串相加结果都是一个字符串 “你好”+6+6+6=“你好666”

9.赋值运算符

,+=,-=,*=,/=.%=

10.自增自减运算符(重点面试)

注意:
0.无论单独运行还是混合运算,只要自增或者自减本身肯定会+1或者-1,只是先后问题
1.++,–自己单独参与计算,++,–写在变量的前边和后边的结果是一样的
2.++,–进行混合运算 ++,–写在变
量的前边,先把变量进行自增或者自减,在使用改变后的值参与计算 ++,–写在变量的后边,先使用变量原来
的值进行计算,计算结果后,在把变量的值自增或者自减
package com.itheima.demo01;
/*
赋值运算符
基本:= 把=右边的值赋值给左边的变量
扩展:+=,-=,=,/=.%=
先把等号左右两边的数进行+,-,,/,%运算,在把结果赋值给左边的变量
隐含了一个强制类型转换

public class Demo05Operator {
public static void main(String[] args) {
int a = 10;
double d = 8.8;
int b = 10;
int c = (int)(b+d);
System.out.println(c);//18
int e = 10;
e+=d;// e= (int)(e+d);
System.out.println(e);//18
}
}
package com.itheima.demo01;
/*
自增自减运算符(重点 面试)
*/
public class Demo06Operator {
public static void main(String[] args) {
//单独计算
int a = 100;
int b = 200;
a++;
--b;
System.out.println("a:"+a);//
System.out.println("b:"+b);//
//混合运算
int aa = 100;

能够说出JDK,JRE,JVM各自的作用和关系(面试)
JDK:称为Java开发工具，包含了JRE和开发工具(java.exe,javac.exe…) JRE:Java运行环境，包含了JVM和
Java的核心类库（Java API String,Scanner…）
JVM:Java虚拟机 JDK>JRE>JVM
跨平台:java程序可以一处编译处处运行
HelloWorld.class
在不同的操作系统上安装对应的java虚拟机(JVM),就可以在操作系统上运行.class文件
加粗样式9.关系(比较)运算符
关系运算符:用于比较两个数字,结果是一个布尔值等于 !=不等于 >大于 <小于 >=大于等于 <=小于等
于
注意: 等于号是 , 千万不要把== 写成 =(赋值)
10.逻辑运算符
用处:用于连接布尔表达式(运算符两边必须是布尔值)
&&: 与运算符有false则false
||: 或运算符有true则true
!:非(取反)运算符非真则假,非假则真
登录:用户登录的用户名和密码与注册的用户名和密码必须都相等==>&&
int bb = 200;
int c = 100+ ++aa +bb++;//
System.out.println(“c:”+c);//
System.out.println(“aa:”+aa);//
System.out.println(“bb:”+bb);//
}
}
//逻辑运算符
//需求:根据用户输入的月份输出对应的季节
Scanner sc = new Scanner(System.in);
System.out.println(“请输入月份:”);
int month = sc.nextInt();
if(month12 || month1 || month2){
System.out.println(month+“是冬季”);
}else if(month3 || month4 || month5){
System.out.println(month+“是春季”);
}else if(month6 || month7 || month8){
System.out.println(month+“是夏季”);
}else if(month9 || month10 || month11){
System.out.println(month+“是秋季”);
}else{
System.out.println(“输入有误!”);
}

11.三元运算符

布尔表达式 ? 表达式1 : 表达式2;
运行规则:
先判断布尔表达式的值
true:使用表达式1作为结果
false:使用表达式2作为结果
注意:
三元运算符的结果是一个值,这个值必须被使用(输出,赋值变量)
获取两个数的最大值

12.if语句

——用于判断(如果条件成立,干什么事)
第一种格式:条件成立执行
执行流程:判断布尔表达式是否成立; true:执行语句体
第二种格式:一定会有一个结果
执行流程:
判断布尔表达式是否成立;
true:执行语句体1
false:执行语句体2
//使用三元运算符获取两个数的最大值
int dd = 10;
int ee = 20;
int max = dd>ee?dd:ee;
System.out.println(“max:”+max);//max:20
if(布尔表达式){
语句体;
}
int b = 20;
if(b>=20){
System.out.println(“b大于等于20”);
}

if(布尔表达式){
语句体1;
}else{
语句体2;
}
第三种格式:用于多条件判断
执行流程:
哪个条件满足成立,执行哪个条件对应的语句体,都不成立,执行else中语句体

13.switch语句

作用:用于多个值中选择一个执行
变量：类型可以为byte、short、int、char，String, 枚举(以后学)。

int b = 20;
if(b%2==0){
System.out.println("b是偶数");
}else{
System.out.println("b是奇数");
}

if(条件1){
语句体1;
}else if(条件2){
语句体2;
}
…
else if(条件n){
语句体n;
}else{
语句体n+1;
}

int b = 20;
if(b>20){
System.out.println("b大于20");
}else if(b<20){
System.out.println("b小于20");
}else{
System.out.println("b等于20");
}

switch(值|整数|字符串){
case 1:
语句体;
break;
case 2:
语句体;
break;
case 3:
语句体;
break;
…
default:
语句体;
break;
}
switch的穿透原理:
在case中不写break,会继续往下执行,直到遇到break结束switch语句

//需求:根据用户输入1-7输出:工作日,休息日

Scanner sc = new Scanner(System.in);
System.out.println("请输入1-7的数字:");
int week = sc.nextInt();
switch (week){
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;
}
}
}
package com.itheima.demo01;
import java.util.Scanner;
public class Demo06Swtich {
public static void main(String[] args) {
//需求:根据用户输入1-7输出:工作日,休息日
Scanner sc = new Scanner(System.in);
System.out.println("请输入1-7的数字:");
int week = sc.nextInt();
switch (week){
case 1:
case 2:

14.for循环

作用:用于代码重复的执行,用于已知循环次数

15.while循环

作用:用于代码重复的执行,用于未知循环次数
case 3:
case 4:
case 5:
System.out.println(“工作日”);
break;
case 6:
case 7:
System.out.println(“休息日”);
break;
default:
System.out.println(“输入有误”);
break;
}
}
}
for(int i=1; i<=次数; i++){
循环体;
}
for(int i=0; i<次数; i++){
循环体;
}

//需求:使用for循环打印10次"HelloWorld"

for (int i = 0; i < 10; i++) {
System.out.println("HelloWorld"+i);
}
System.out.println("-----------------------");
for (int i = 1; i <= 10; i++) {
System.out.println("HelloWorld"+i);

16.do while循环(面试)

作用:用于代码重复的执行,至少会执行一次循环体(先执行,后判断)

17.跳转控制语句

break:跳出单层循环,结束switch语句
continue:跳出本次循环,继续下一次循环
int i = 1;
while(i<=次数){
循环体;
i++;
}
//死循环:猜数字小游戏折纸:纸的厚度大于山峰高度学员管理系统,选择退出,结束死循环

while(true){
循环体;
}
int i=1;
do{
循环体;
i++;
}while(i<=次数);
package com.itheima.demo03;
public class Demo10DoWhile {
public static void main(String[] args) {
int i = 1;
do{
System.out.println("hello");
i++;
}while (i<1);
//问题:hello会打印几次? 1次
}
}
package com.itheima.demo03;
public class Demo11breakAndcontinue {
public static void main(String[] args) {
for (int i = 1; i <=10; i++) {
if(i%2==0){
//break;//1
continue;//1 3 5 7 9
}
System.out.println(i);

18.循环嵌套

循环中的循环体又是一个循环
三种循环都可以相互嵌套,使用最多的就是for嵌套for
外层循环控制打印的行数,内层循环控制打印的列数

19.Random随机数(重点)

//获取任意区间的随机数公式:(大数-小数+1)+小数;
//需求:获取15-88之间的随机整数
package com.itheima.demo03;
import java.util.Random;
/*
//获取任意区间的随机数公式:(大数-小数+1)+小数;
//需求:获取15-88之间的随机整数
*/
public class Demo13Random {
public static void main(String[] args) {
Random r = new Random();
int a = r.nextInt(88-15+1)+15;// r.nextInt(74)+15;>[0,73]+15>[15,88]
System.out.println(a);

20.会使用debug调试代码,看代码逐行执行,看方法的调用过程

21.数组的作用

用于存储同种数据类型的多个元素的一个容器

22.数组的两种定义格式

动态初始化:指定数组长度,包含默认值
int[] arr = new int[10]; 有默认值0
静态初始化:指定数组中的元素
int[] arr = new int[]{1,2,3,4,5}; 简化 int[] arr = {1,2,3,4,5};

23.数组的遍历(重点)

依次打印数组中的元素
int b = r.nextInt(7-1+1)+1;//r.nextInt(7)+1==>[0,6]+1==>[1,7]
System.out.println(b);
}
}
操作步骤:

在行号的右边添加断点,初学者一般在main方法的第一行添加一个断点
在代码区域右键Debug执行,程序就会停留在添加的第一个断点处
看Debugger窗口,看变量的变化
看Console窗口,控制台看输出结果
让代码逐行执行
f8:逐行执行代码,但是不会进入到方法中执行
f7:逐行执行代码,会进入到方法中执行(建议)
f9:跳到下一个断点
让程序停止
点Stop结束(红色方块)
删除断点

鼠标左键再次点击断点删除
批量删除断点

24.数组的常见操作(必须掌握)

a.求和
a.求最大值,最小值

25.数组中两种常见的运行异常

a.空指针异常:数组的值为null,就不能在使用了
b.数组索引越界异常:访问了数组不存在的索引

//定义一个数组
int[] arr = {1,2,3,4,5};
//数组的遍历(重点) 快捷键: 数组名.fori==>回车
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
System.out.println("======================");
//反向遍历:很少使用 从后往前依次打印每一个元素
for (int i = arr.length-1; i >=0 ; i--) {
System.out.println(arr[i]);
}
//定义一个数组
int[] arr = {1,2,3,4,5};
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum+=arr[i];
}
System.out.println("sum:"+sum);
//定义一个数组
int[] arr = {1,2,3,4,5};
//求最大值和最小值
int max = arr[0];
int min = arr[0];
for (int i = 0; i < arr.length; i++) {
if(arr[i]>max){
max = arr[i];
}
if(arr[i]<min){
min = arr[i];
}
}
System.out.println("max:"+max);
System.out.println("min:"+min);
package com.itheima.demo01;
public class Demo13Array {
public static void main(String[] args) {
int[] arr = {1,2,3};

26.方法的概念

Java中的方法：可以将“一段功能代码”封装成一个独立的“代码块”，并且起个“名字” ，当其他的代码需
要这段功能，就可以通过“名字”调用这段代码。方法的好处：提高代码的重用性(重复使用多次)! 封装一
个功能

27.方法的定义格式(重点)

28.方法的使用格式

方法名(实际参数); 1.没有返回值的方法:直接调用 printArray(arr); 2.有返回值的方法 a.输出调用:返回值
只能使用一次 System.out.println(getMax(arr)); b.赋值调用:返回值可以反复的使用(建议) int max =
getMax(arr);

29.方法练习


//索引 0 1 2
System.out.println(arr[0]);//1
System.out.println(arr[1]);//2
System.out.println(arr[2]);//3
//System.out.println(arr[3]);//ArrayIndexOutOfBoundsException: 3 索引越界
异常
arr = null;//数组对象(房子)不存在
System.out.println(arr[0]);//NullPointerException:空指针异常
}
}

修饰符返回值类型方法名(参数列表){
方法体;
return 返回值;
}
修饰符:固定public static
返回值类型:void,任意的数据类型
参数列表:任意的数据类型

**package com.itheima.demo03method;
/*
需求:定义一个方法,对String类型的数组进行遍历
三要素:
方法名:printArray
参数列表:String[] arr
返回值类型:void
*/
public class Demo01Method {
public static void main(String[] args) {
String[] arr = {"jack","rose","tom"};
//调用方法
printArray(arr);
//方法的好处:可以重复使用
String[] arr2 = {"张三","李四","王五","赵六","田七"};
printArray(arr2);**

30.参数概念

形式参数: 定义方法时写的参数getMax(int a,int b) 形式参数定义的时候没有值
实际参数: 调用方法时传递的实际的参数 getMax(10,20);
基本数据类型作为参数:是值传递，仅仅用于赋值，形参改变不影响实参
引用数据类型作为参数:是地址值传递,结果是多个变量会指向堆内存中的同一个对象
一个引用变量修改了对象的值,另外一个变量在使用的就是改变后的值
}
/*
定义一个方法,对String类型的数组进行遍历
*/

public static void printArray(String[] arr){
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
package com.itheima.demo03method;
public class Demo02Method {
public static void main(String[] args) {
int a = 10;
int b = 20;
show(a,b);//仅仅是一个赋值:形参改变不影响实参
System.out.println("a:"+a);//a:10
System.out.println("b:"+b);//b:20
System.out.println("----------------------");
int[] arr = {1,2,3};
show(arr);//传递的是地址值:形参改变影响实参
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);//2,4,6
}
}
public static void show(int[] arr){
for (int i = 0; i < arr.length; i++) {
arr[i]*=2;
}
}
public static void show(int a,int b){
a+=10;
b-=10;
System.out.println("a:"+a);//a:20
System.out.println("b:"+b);//b:10
}
}
package com.itheima.demo03method;
/*

需求:
已知有以下数组 int[] arr= {10,20,30,40};
请定义一个方法,计算数组中所有元素的和,并把和返回到main方法中打印
三要素:
方法名:getSum
参数列表:int[] arr
返回值类型:int

*/
public class Demo03Test {
public static void main(String[] args) {
int[] arr= {10,20,30,40};
int sum = getSum(arr);
System.out.println("sum:"+sum);
}
public static int getSum(int[] arr){
int sum = 0;
for (int i = 0; i < arr.length; i++) {
sum+=arr[i];
}
return sum;
}
}
package com.itheima.demo03method;
/*

需求:
已知有以下数组 int[] arr= {100,90,60,38,59,66,99};
请定义一个方法,统计数组中大于等于60分的元素个数,并把统计结果返回到main方法中打印
三要素:
方法名:getCount
参数列表:int[] arr
返回值类型:int
1.定义一个int类型的变量count,初始值为0,记录个数
2.遍历数组,获取每一个元素
3.判断元素>=60
4.条件成立,统计变量count++
5.循环结束,把count返回
/
public class Demo04Test {
public static void main(String[] args) {
int[] arr= {100,90,60,38,59,66,99};
int count = getCount(arr);
System.out.println(“count:”+count);
}
/
请定义一个方法,统计数组中大于等于60分的元素个数,并把统计结果返回到main方法中打印
三要素:
方法名:getCount
参数列表:int[] arr
返回值类型:int

*/
public static int getCount(int[] arr){
//1.定义一个int类型的变量count,初始值为0,记录个数
int count = 0;
//2.遍历数组,获取每一个元素
for (int i = 0; i < arr.length; i++) {
//3.判断元素>=60
if(arr[i]>=60){
//4.条件成立,统计变量count++
count++;
}
}
//5.循环结束,把count返回
return count;
}
}
package com.itheima.demo03method;
/*
需求:
已知有以下数组 int[] arr= {100,90,60,38,59,66,99};
请定义一个方法,计算数组中元素的最大值,并在方法中打印最大值
三要素:
方法名:getMax
参数列表:int[] arr
返回值类型:void
1.定义一个int类型的变量max,把数组中第一个元素赋值给max
2.遍历数组,获取数组中的其他元素
3.判断元素>max
4.条件成立,把元素赋值给max
5.循环结束,打印max
*/
public class Demo05Test {
public static void main(String[] args) {
int[] arr= {100,90,60,38,59,66,99};
getMax(arr);
}
/*

请定义一个方法,计算数组中元素的最大值,并在方法中打印最大值
三要素:
方法名:getMax
参数列表:int[] arr
返回值类型:void
*/
public static void getMax(int[] arr){
//1.定义一个int类型的变量max,把数组中第一个元素赋值给max
int max = arr[0];
//2.遍历数组,获取数组中的其他元素
for (int i = 1; i < arr.length; i++) {
//3.判断元素>max
if(arr[i]>max){
//4.条件成立,把元素赋值给max
max = arr[i];
}
}

31.方法重载(重点)

在同一个类中,出现了方法名相同,但是参数列表不同的方法,叫方法重载(Overload)
参数列表不同: 1.个数 2.类型 3.顺序

32.面向对象的概念(非常重要)

面向对象基于面向过程
面向过程:当我们遇到一件事情的时候,自己分析解决的步骤,按照步骤一步一步完成这件事情;重视
的是完成事情的过程
面向对象:当我们遇到一件事情的时候,我们不自己完成,找到一个具有完成该事情功能的对象,调用
对象中的方法完成;重视的是对象,使用对象调用方法
特点
面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成
了指挥者。面向对象的语言中，包含了三大基本特征，即封装、继承和多态。

33.类和对象的关系

类：就像一个“图纸”，就像一个模版一样
对象：就像一个“通过图纸生产出的产品”；就是根据类创建出来的具体是事物,可以根据类创建无数多个
对象
例如:
学生类Student:
属性:姓名,年龄
行为:吃饭,睡觉,学习
根据类创建对象:
1.张三,18 吃米饭,躺床上睡,学习java
2.李四,19 吃面条,躺床上睡,学习java

34.封装

概念:私有成员变量,对外提供公共的get/set方法
//循环结束,打印max

**System.out.println("max:"+max);
}
}
public static int getSum(int a,int b){}
public static int getSum(int a,int b,int c){}
public static double getSum(double a,double b){}
public static double getSum(int a,double b){}
public static double getSum(double a,int b){}**

好处:
可以让成员变量更加安全,不让用户直接访问成员变量,必须通过get/set方法
可以让变量提供只读功能,只给变量添加get方法

35.this关键字

问题:
当局部变量和成员变量重名时,局部变量会隐藏成员变量的值解决:使用**this.**变量名==>代表访问的
是成员变量 this代表本(Student)类对象的引用(引用:引用的对象堆内存中的地址值) 哪个对象调用的方
法,方法中的this就是哪个对象

36.构造方法

构造方法:创建对象,就是调用类中的构造方法完成
格式:
public 类名(){}
public 类名(参数列表){
给成员变量赋值
}
构造方法的作用:
1.为对象开辟内存空间,赋初始化值
2.带参构造方法,可以给成员变量赋指定值(相当于set方法)
构造方法的注意事项:
1.如果类中没有明确写出构造方法,那么java会为类增加一个默认的构造方法
格式:public Student(){}
2.如果类中有明确写出构造方法,那么系统就不会为类增加默认的构造方法
如果想使用空参数构造方法,必须手动写出
3.构造方法可以重载(在一个类中,出现了方法名相同,但是参数列表不同(个数,类型,顺序)的方法)

new Student();使用空参数构造方法创建Student对象
public Student(){}
new Student("jack");使用给name赋值的构造方法创建Student对象
public Student(String name){
this.name=name;
}
new Student(18);使用给age赋值的构造方法创建Student对象
public Student(int age){
this.age=age;
}
new Student("rose", 20);使用同时给name和age赋值的构造方法创建Student对象
public Student(String name,int a){
this.name=name;
this.age= age;
}

37.JavaBean(重点):标准java类

38.成员变量和局部变量区别

1.在类中的位置不同 (重点)
成员变量：类中，方法外
局部变量：方法中或者方法声明上(形式参数)
2.初始化值的不同 (重点)
成员变量：有默认值,可以直接使用
局部变量：没有默认值。必须先定义，赋值，最后使用
3.作用范围不一样:变量在所在的大括号{}的范围内有效 (重点)
成员变量：类中的任意方法中,都可以使用
局部变量：只能在本方法中使用
4.在内存中的位置不同了解
成员变量：堆内存
局部变量：栈内存
5.生命周期不同了解
成员变量：随着对象的创建而存在，随着对象的消失而消失
局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
要求:
1.使用封装的思想:私有成员变量,对外提供公共的get/set方法
2.给类中添加空参数和满参数构造方法
快捷键:
1.get/set快捷键
alt+insert(ins)>选择Getter and Setter>全选(ctrl+a)>点击ok
fn+alt+insert(ins)>选择Getter and Setter==>全选(ctrl+a)>点击ok
鼠标右键点击空白地方,选择Genrate>选择Getter and Setter==>全选(ctrl+a)>点击
ok
2.构造方法快捷键
空参数:alt+insert(ins)>选择Constructor==>选择Select None
满参数:alt+insert(ins)>选择Constructor>全选(ctrl+a)==>点击ok

39.String类

40.StringBuilder类

综合案例1-学员类设计
String类：
构造方法:
String() 创建一个空的字符串对象
String(String original) 通过参数传递的字符串常量,创建一个新的字符串对象
String(char[] value)通过参数传递的字符数组,创建一个新的字符串对象
String(byte[] bytes)通过参数传递的字节数组,查询编码表,创建一个新的字符串对象
成员方法:

public boolean equals(String anObject)：比较两个字符串的内容是否相同
public char charAt(int index)：获取指定索引上的字符
public int length()：获取字符串的长度
public String substring(int beginIndex)：从beginIndex位置开始，截取到字符
串的末尾
public String substring(int beginIndex, int endIndex)：从beginIndex开
始，截取到endIndex – 1处
public String replace(String old, String newStr)：将当前字符串中的old字符
串替换为newStr

StringBuilder类：
构造方法:
StringBuilder()构造一个不带任何字符的字符串生成器，其初始容量为 16 个字符。
StringBuilder(String str)构造一个字符串生成器，并初始化为指定的字符串内容。
成员方法:

public StringBuilder append (任意类型)添加数据，并返回对象本身
public StringBuilder reverse()：返回相反的字符序列
public int length•()：返回长度
public String toString•()：把StringBuilder转换为String类型
package com.itheima.demo04test;
public class Student {
//私有成员变量
//学号(int id)、
private int id;
//姓名(String name)、
private String name;
//性别(String sex)、
private String sex;
//年龄(int age)
private int age;
//给类添加一个空参数构造方法,一个满参数构造方法(快捷键)

public Student() {
}
public Student(int id, String name, String sex, int age) {
this.id = id;
this.name = name;
this.sex = sex;
this.age = age;
}

/*
print方法:要求在方法中打印学员的所有信息(学号,姓名,性别,年龄)
学号:1
姓名:张三
性别:男
年龄:18
*/
public void print(){
System.out.println(“学号:”+id);
System.out.println(“姓名:”+name);
System.out.println(“性别:”+sex);
System.out.println(“年龄:”+age);
}

//study方法:要求在方法中打印"good good study,day day up!"
public void study(){
System.out.println("good good study,day day up!");
}
//对外提供公共的get/set方法(快捷键)
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
package com.itheima.demo04test;
/*

综合案例1-学员类设计

请以“封装”的思想定义以下类，并为其定义构造方法
1.为“学员管理系统”设计一个“学员类(Student)”：
成员属性(成员变量)：学号(int id)、姓名(String name)、性别(String sex)、年龄(int
age)
成员方法：打印学员信息(print)、学习(study)
print方法:要求在方法中打印学员的所有信息(学号,姓名,性别,年龄)
学号:1
姓名:张三
性别:男
年龄:18
study方法:要求在方法中打印"good good study,day day up!"
1.封装思想:私有成员变量,对外提供公共的get/set方法(快捷键)
2.给类添加一个空参数构造方法,一个满参数构造方法(快捷键)
2.创建测试类:Demo01Student
在测试类中添加main方法
在main方法中使用空参数构造方法创建Student对象,使用set方法给成员变量赋值
调用Student类中的print方法和study方法
在main方法中使用满参数构造方法创建Student对象
调用Student类中的print方法和study方法
*/
public class Demo01Test {
public static void main(String[] args) {
//在main方法中使用空参数构造方法创建Student对象
Student s1 = new Student();
//使用set方法给成员变量赋值
s1.setId(1);
s1.setName("赵四");
s1.setAge(44);
s1.setSex("男");
//调用Student类中的print方法和study方法
s1.print();
s1.study();
//在main方法中使用满参数构造方法创建Student对象
Student s2 = new Student(2,"刘能","男",40);
//调用Student类中的print方法和study方法
s2.print();

综合案例2-航班类设计

s2.study();
}
}
package com.itheima.demo04test;
public class Flight {
//私有成员变量
//航班号(String flightNum)
private String flightNum;
//航空公司(String airline)
private String airline;
//起点站(String from)
private String from;
//终点站(String to)
private String to;
//票价(double fare)
private double fare;
//给类添加一个空参数构造方法,一个满参数构造方法
public Flight() {
}
public Flight(String flightNum, String airline, String from, String to,
double fare) {
this.flightNum = flightNum;
this.airline = airline;
this.from = from;
this.to = to;
this.fare = fare;
}
/*
成员方法：打印航空信息(print)
航班号:CA1369
航空公司:中国国航
起点站:首都机场T3
终点站:凤凰机场T2
票价:1010.0
*/
public void print(){
System.out.println("航班号:"+flightNum);
System.out.println("航空公司:"+airline);
System.out.println("起点站:"+from);
System.out.println("终点站:"+to);
System.out.println("票价:"+fare);
}
//对外提供公共的get/set方法
public String getFlightNum() {
return flightNum;
}
public void setFlightNum(String flightNum) {
this.flightNum = flightNum;
}
public String getAirline() {
return airline;
}
public void setAirline(String airline) {
this.airline = airline;
}
public String getFrom() {
return from;
}
public void setFrom(String from) {
this.from = from;
}
public String getTo() {
return to;
}
public void setTo(String to) {
this.to = to;
}
public double getFare() {
return fare;
}
public void setFare(double fare) {
this.fare = fare;
}
}
package com.itheima.demo04test;
/*

综合案例2-航班类设计

请以“封装”的思想定义以下类，并为其定义构造方法
1.为“航班管理系统”设计一个“航班类(Flight)”：
成员属性：航班号(String flightNum)、航空公司(String airline)、起点站(String
from)、终点站(String to)、票价(double fare)
成员方法：打印航空信息(print)
航班号:CA1369
航空公司:中国国航
起点站:首都机场T3
终点站:凤凰机场T2
票价:1010.0
1.封装思想:私有成员变量,对外提供公共的get/set方法(快捷键)
2.给类添加一个空参数构造方法,一个满参数构造方法(快捷键)
2.创建测试类:Demo02Flight
在测试类中添加main方法
在main方法中使用空参数构造方法创建Flight对象
使用set方法给成员变量赋值
调用Flight类中的print方法
在main方法中使用满参数构造方法创建Flight对象
调用Flight类中的print方法
*/
public class Demo02Test {
public static void main(String[] args) {
//在main方法中使用空参数构造方法创建Flight对象
Flight f1 = new Flight();
//使用set方法给成员变量赋值
f1.setFlightNum("CA2861");
f1.setAirline("中国国航");
f1.setFrom("滨海国际机场T2");
f1.setTo("江北国际机场T3");
f1.setFare(866);
//调用Flight类中的print方法
f1.print();
//在main方法中使用满参数构造方法创建Flight对象
Flight f2 = new Flight("MF8622","厦门航空","滨海国际机场T2","江北国际机场
T3",916);
//调用Flight类中的print方法
f2.print();
}
}__