总结
for循环
第一天
格式：
for(初始化语句；条件表达式；控制语句或者步长语句){
循环体语句；…
}
执行流程:
1)先初始化语句进行赋值
2)判断条件表达式是否成立,如果成立,执行循环体语句
2.1)继续执行控制台语句或者步长语句 对初始化语句的变量进行自增或者自减
2.2)继续判断条件表达是否成立,如果成立,按照上面 这种方式执行;
2.3)如果变量自增或者自减到条件表达式不成立为止,循环语句结束!
例子：打印五遍"HelloWorld"
class WhileDemo{
public static void main(String[] args){
for(int x=1;x<=5；x++){
System.out.println("helloworld") ;
}
}
例子：1)在dos控制台打印输出1-10的所有数据!
2)在dos控制台打印输出1-10的所有数据之和!(循环)
class ForTest2{
public static void main(String[] args){
int sum=o;/*定义一个结果变量：结果变量即最后你要的结果。即你要打印1- 10的数据和*/
for(int x=1;x<=10;x++){
sum+=x;
}
System.out.println("1-10的数据之和是:"+sum) ;
}
}
水仙花数-for循环
什么是水仙花数:
水仙花数指的是三位数,而且这个三位数每个位上的数据的立方之和是它本身
//求100-1000的水仙花数
153 = 1*1*1+5*5*5 +3*3+3
class ForTest3{
public static void main(String[] args){
System.out.println("水仙花数是:") ;
for(int x=100;x<=999;x++){//"x"相当于就是结果变量 你最后要的数字
//定义这个三位数的个十百位的数字变量
int ge = x % 10 ; //个位
int shi = x /10%10 ; //十位
int bai = x /10/10 %10 ;//百位
if((x==(ge*ge*ge+shi*shi*shi+bai*bai*ba))
System.out.println(x) ;//x就是结果变量 就是你要求的数字
}
}
}
//求100-1000的水仙花数个数！
思路： 1)定义统计变量 int count = 0 ;
2)水仙花数---明确范围 for循环 x 的取值100-999
2.1)定义三个变量 int ge = x % 10 ;
int shi = x/10 % 10 ;
int bai = x/10/10%10;
2.2)如果满足条件x==(ge*ge*ge+shi*shi*shi+bai*bai* bai)
2.3)统计变量++即可
3)输出统计变量即可!
class ForTest4{
public static void main(String[] args){
int count = 0 ;//1)定义统计变量
//2)水仙花:三位数
for(int x = 100; x<=999; x++){
//个位,百位,十位三个变量
//获取x这个数据每个位上的数据本身
int ge = x % 10;
int shi = x /10%10;
int bai = x /10/10 %10;//循环体
//2.1)如果满足条件x==(ge*ge*ge+shi*shi*shi+bai*bai* bai)
if(x==(ge*ge*ge+shi*shi*shi+bai*bai*bai)){
//2.2)统计变量++
count ++ ;//控制语句
System.out.println("第"+count+"次的水仙花数是:"+x) ;
}
}
System.out.println("水仙花数共有:"+count+"个");
}
}
while 循环
格式：
基本格式：
while（条件表达式）{
循环体语句；
控制体语句或者步长语句；
}
扩展格式：（常用）
初始化语句：
while（条件表达式）{
循环体语句；
控制体语句或者步长语句；
}
例子：打印五次HelloWorld
class WhileDemo{
public static void main(String[] args){
int x=1;//初始化语句或者初始化值
while(x<=5){//小括号里是条件表达式
System.out.println(“helloworld”) ;//循环体
x++;//控制语句
}
水仙花数-while循环
举例1：
打印1-100的偶数和
class WhileTest{
public static void main(String[] args){
//1-100偶数和
int x = 1 ;//设置初始表达式
//结果变量
int sum = 0 ;//定义结果变量
while(x<=100){
if(x%2==0){
sum +=x ;//循环体语句
}
x++ ;//控制体语句
}
System.out.println("1-100偶数和是:"+sum) ;
举例2：
int count = 0 ;//定义统计变量
int i = 100;//定义初始表达式
while(i<=999){//循环体
//定义三个变量
int ge = i % 10 ;
int shi = i /10 % 10 ;
int bai = i /10/10 % 10;
if(i ==(ge*ge*ge+shi*shi*shi+bai*bai* bai)){
count ++ ;//控制语句
System.out.println("第"+count+"次的水仙花是:"+i) ;
}
i ++ ;//控制语句2
}
System.out.println("共有"+count+"个") ;
}
}
switch循环
格式：
switch语句格式
switch(表达式){
case 值1:
语句1;
break ;
case 值2:
语句2;
break ;
…
…
default:
语句n;
break ;
}
执行流程:
1)表达式中的值先和case值1比较,如果匹配,执行语句1,语句break,语句结束;
2)case值1不匹配,继续和case值2进行比较,如果一致,执行语句2,swich结束;
…
…
3)如果上面的case的值和表达式中的结果值都不匹配,执行default语句,
执行语句n,switch语句结束;
import java.util.Scanner;
/*
输入数字得出周几
*/
class Test11{
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
System.out.println("请输入数字");
int a=sc.nextInt();
switch(a){
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("今天周日");
default:
System.out.println("输入有误");
}
}
}
死循环
常见格式：
常见的两种死循环格式
for( ; ; ){ //jdk源码中比较多
循环体…
}
-----------------------------------------------------------------------
while(true){ //推荐
循环体…
}
利用死循环解决一些问题!
死循环:肯定需要利用一些条件,当达到某种条件的时候,结束循环(break;中断,结束!)
/*
常见的两种死循环格式
for(;;){ //jdk源码中比较多
循环体...
}
while(true){ //推荐
循环体...
}
利用死循环解决一些问题!
死循环:肯定需要利用一些条件,当达到某种条件的时候,结束循环(break;中断,结束!)
*/
class WhileDemo3{
public static void main(String[] args){
/*
for(;;){
//逻辑:达到一种条件,break
System.out.println("今天很开心,学习了死循环!") ;
}
*/
//第二种格式
while(true){
//逻辑:达到一种条件,break
System.out.println("今天很开心,学习了死循环!") ;
}
}
}
while和for的区别?
共同点:
都是使用循环思想解决一些问题
不同点:
1)格式本身不同
for(初始化语句;条件表达式;控制体语句){
循环体语句;
}
初始化语句;
while(条件表达式){
循环体语句;
控制体语句;
}
2)是否明确循环次数
for循环:明确循环次数优先for循环,(for还是很频繁使用的)
while循环:不明确循环次数,使用while循环
3)从内存角度考虑销毁不同:
for循环结束,里面的变量及时释放了,所以不能在访问for中的变量
whlile循环结束,依然可以访问里面变量,
所以消耗资源相对for循环大一些!
拓展：引用jdk源码随机数游戏
需求:
键盘录入int类型的数据,猜数字游戏(1-100之间的数据!)
jdk提供了一个类java.lang.Math(不需要导包):数学运算的工具
random()这个函数可以获取[0.0,1.0)的随机数 (常用类讲)
分析:
1)产生一个1-100之间的随机数(利用jdk提供Math完成)–number
while(true){
2)不断的创建键盘录入对象,录入int类型的数据–guessNumber
3)判断
如果guessNumber > number ,提示数据大了
否则如果guessNumber < number ,提示数据小了
最终,一致! 结束循环,break(中断,结束);
}
for-循环猜数字游戏 （1-100）
for(int x = 1 ; x <=10 ;x++){
//0.0-1.0的随机数:取不到1.0
//double number = Math.random() ;
//1-100的随机数 int
int number = (int)(Math.random()*100+1);
//由于只能取0.0-1.0的数字 所以要*100+1
System.out.println(number) ;
}
while-循环猜数字游戏（1-100）
import java.util.Scanner ;
class WhileTest2{
public static void main(String[] args){
int number = (int)(Math.random()*100+1) ;//
System.out.println("猜数字游戏开始了...") ;
//定义一个统计变量
int count = 0 ;
while(true){
//统计变量++
count ++ ;
//2)创建键盘录入对象
Scanner sc = new Scanner(System.in ) ;
//3)提示并录入数据
System.out.println("请您输入要猜的数据:") ;
int guessNumber = sc.nextInt() ;
if(guessNumber<1 || guessNumber>100){
System.out.println("您输入的数据不合法!") ;
}else if(guessNumber > number){
System.out.println("您要猜的数据"+guessNumber+"大了") ;
}else if(guessNumber < number){
System.out.println("您要猜的数据:"+guessNumber+"小了") ;
}else{
System.out.println("恭喜您,第"+count+"次,猜对了!") ;
break ;//满足条件,结束死循环
}
}
}
}
第二天
do while
do…while循环和while循环相似，不同的是，do…while 循环至少会执行一-次。
初始化语句；
do{
循环体；
控制体；
}while(条件表达式);
1）初始化赋值
2）循环体-控制体-完成条件判断
和while的区别
while先判断后执行。do-while是先执行后判断!
Do…while总是保证循环体会被至少执行一次! 这是他们的主要差别。**
小知识
System exit(0);终止jvm
String sc=sc.nextStringLine();Line原意就是换行的意思
输出打印一个整数和一个字符串的时候要么省略Line要么在打印字符串之前再创建一个新的扫描器专门打印字符串
牛客 力扣 剑指offer
{break /continue /return}
break:结束中断的意思
·
1)循环语句中使用,结束循环用的
2)switch语句中使用,结束switch
不能单独使用,不能脱离上面两种场景!
class BreakDemo{
public static void main(String[] args){
//break; 在 switch 或 loop 外部中断
for(int x = 1 ; x <=10 ; x++){
if(x == 3){
break ;//结束,中断
}
System.out.println(x) ;
}
System.out.println("-----------------------------") ;
wc:for(int x = 0 ; x < 5 ; x ++){//行数 //x=0 ,0<5,1<5
nc:for(int y = 0 ; y <6 ; y ++){//列数 y=0,0<6,1<6,2<6,3<6
/*
if(x==3){//四行
//break wc;//结束外层循环
}
*/
if(y==3){
/*
x=0 0<5 x++=1
y=0 0<6 y++=1
x=1 1<5 x++=2
y=1 1<6 y++=2
x=2 2<5 x++=3
y=2 2<6 y++=3
y==3 符合条件 break;
x=3 3<5 x++=4
x=4 4<5 x++=5
x=5 5<5不成立 结束;
x=5 y=3 即五行三列
*/
break nc;
}
System.out.print("*") ;
/*
***
***
***
***
***
*/
}
System.out.println();//换行
}
}
}
此图代表输出到==3的时候结束 输出为1，2
beak 早期使用方法 for循环前的标签；结束内/外循环
早期使用:break 标签名称; 结束指定的循环
在for循环嵌套中,给for循环的前面加上一个 "标签名称:"
wc:代表外层循环
nc:代表内层循环
wc:for(初始化语句;条件表达式;控制体语句){
nc:for(初始化语句2;条件表达式2;控制体语句2;){
//循环体;
//当达到我指定的条件,
break wc;//结束外层循环了
}
}
continue：继续循环的意思
continue:继续执行(结束当前循环,立即进入下一次循环)
1）不能单独使用
例子：
for(int x =1 ; x<=10;x++){
if(x%3==0){//x=3,6,9符合 跳过
//补全代码
//continue;
//补一句“ System.out.println("我爱高圆圆!") ;”//补一句的话就是直接运行10+3次 *//意思就是没有“System.out.println("我爱高圆圆!") ;”的时候打印十次。加一句的就多了三次符合条件if(x%3==0)时的打印；
}
System.out.println("我爱高圆圆!") ;
}
//1)想在控制台输出7次 "我爱高圆圆" continue
//2)想在控制台输出13次 "我爱高圆圆" System.out.println("我爱高圆圆!") ;
class ContinueDemo{
public static void main(String[] args){
//continue ; //continue 在 loop 外部 (仅仅在循环语句中使用)
for(int x = 1 ;x<=10;x++){
if(x==4){
//continue:继续执行(结束当前循环,立即进入下一次循环)
continue ;
}
System.out.println(x) ;//1235678910
}
}
}
return：返回的意思
1）很少单独去使用(不建议),后面一般都会有返回结果值;
在Java中的方法(函数)中去使用,目的就是结束这个有返回值类型的 方法, 并且还有返回结果;
class ReturnDemo{
public static void main(String[] args){
//for循环
System.out.println("程序开始了") ;
for(int x = 1 ; x <= 10 ;x ++){
if(x ==3){
System.out.println("进入if了...") ;
//break ;//结束,中断的意思
//continue ;//结束当期循环,继续进入下一次循环
return ; //结束方法了 打印方法结束 不出现下面的"over..."
}
System.out.println("x的值是:"+x) ;
}
System.out.println("over....") ;
}
}
方法
执行语句的集合 {}包裹起来–代码块 可重复利用提高代码的复用性
注意事项:
1)方法和方法平级关系,不能在一个方法中去定义另一个方法!
2)定义方法的返回值类型和main方法中调用方法一致,否则接收结
果类型不匹配!
3)Java是强类型语言,在定义的方法时候,
形式参数名前面必须有参数类型
4) 必须有return语句,没有就会编译报错!
5)定义方法的时候,有{号地方不能有分号;有分号;,不能有{左大括号
定义格式
必须在同一个类下 不能在类大括号外创建
public static 返回值类型 方法名(形式参数类型1 参数名1,形式参数类型2 参数名2…){
//完成方法的逻辑
return 结果;
}
定义方法:
两个明确:
1)明确返回值类型
2)明确参数类型以及参数个数
1)单独调用 —方法名(实际参数列表) ; (有返回类型的方法不能使用)
2)输出调用 —System.out.println(方法名(实际参数列表)) ;输出调用:可以,写死了,如果相对结果值在进行操作,就不能用了
3)赋值调用:(推荐)
输入两个数判断是否相等；
第三天
//方法（有无返回值的类型）//数组 //jvm//数组遍历，求极值
有返回值类型的方法定义
执行语句的集合 {}包裹起来–代码块 可重复利用提高代码的复用性
注意事项:
1)方法和方法平级关系,不能在一个方法中去定义另一个方法!
2)定义方法的返回值类型和main方法中调用方法一致,否则接收结
果类型不匹配!
3)Java是强类型语言,在定义的方法时候,
形式参数名前面必须有参数类型
4) 必须有return语句,没有就会编译报错!
5)定义方法的时候,有{号地方不能有分号;有分号;,不能有{左大括号
定义格式
必须在同一个类下 不能在类大括号外创建
public static 返回值类型 方法名(形式参数类型1 参数名1,形式参数类型2 参数名2…){
//完成方法的逻辑
return 结果;
}
关键
定义方法:
两个明确:
1)明确返回值类型
2)明确参数类型以及参数个数
1)单独调用 —方法名(实际参数列表) ; (有返回类型的方法不能使用)
2)输出调用 —System.out.println(方法名(实际参数列表)) ;输出调用:可以,写死了,如果相对结果值在进行操作,就不能用了
3)赋值调用:(推荐)
输入两个数判断是否相等；
import java.util.Scanner ;
class FunctionTest{
public static void main(String[] args){
//1)键盘录入两个数据,定义一个方法,比较两个数据是否相等
//创建键盘录入对象
Scanner sc = new Scanner(System.in) ;
//提示并录入数据
System.out.println("请您输入第一个数据:") ;
int firtNum = sc.nextInt();
System.out.println("请您输入第二个数据:") ;
int secNum = sc.nextInt();
//调用比较两个数据是否相等的方法
boolean result = compare(firtNum,secNum) ;//实际参数
System.out.println(result) ;
}
public static boolean compare(int a,int b){
//三元/if..else...
//完成的逻辑
if(a==b){
return true ;
}else{
return false ;
}
//boolean flag = (a==b)?true:false ;
//return flag ;
//return a==b;
}
输入两三个数判断最大值
import java.util.Scanner ;
class FunctionTest{
public static void main(String[] args){
//键盘录入三个数据,定义一个方法,比较三个数据的最大值
//提示并录入数据
System.out.println("请您输入第一个数据:") ;
int a = sc.nextInt();
System.out.println("请您输入第二个数据:") ;
int b = sc.nextInt();
System.out.println("请您输入第三个数据:") ;
int c = sc.nextInt();
//调用方法
int max = getMax(a,b,c);
System.out.println("三个数据最大值:"+max);
}
public static int getMax(int a,int b,int c){
//三元/if...else...
//定义max
int max ;
if(a>b){
if(a>c){
max = a;
}else{
max = c;
}
}else{
if(b>c){
max = b ;
}else{
max = c ;
}
}
return max ;
}
没有返回值类型的方法定义
（1）没有具体返回值类型的方法的定义:
针对某个功能代码块{} 没有具体的返回值类型,按照语法规定:必须有一个值
Java提供了一个关键字:代替没有具体返回值类型 void
（2）固定格式:
public static void 方法名(形式参数列表){
方法体中的内容:直接输出 或者进行其他操作;(不需要return语句了)
}
（3）没有具体返回值类型的方法调用
（a）单独调用:只能单独调用
(b) 输出调用:不行
© 赋值调用:不行
方法重载
方法名一样；参数列表不一样（参数个数 顺序 类型不一样）；
与返回值无关这样的一系列方法都称为 方法重载
举例：
1 public static void sum(int a ，int b)
2 public static void Sum(int a ，double b)
3 public static void SUM(int a， int b)
4 public static void sum(double a ，double c,int b)
5 public static void sum(int a， int b)
结论：1，2，4，5是方法重载
JVM内存结构
大致分为五部分
栈内存
默认的int 类型数组的值是0；角标值（索引值）
存储的是局部变量（在方法定义以及方法声明中的变量）；随着调用而存在；随着使用方法的结束而消失；方法的形式参数如果是基本数据类型，形式参数的改变，并不会影响实际参数
进栈的方法是由上到下的
压栈 弹栈
堆内存
创建出来的东西(实例 又称为对象) 如：Scanner sc=new Scanner;
存储在堆中
方法区
字节码文件区域 存储着方法 每一个加载进栈的内存叫"栈帧"
静态区域 static
常量区
本地方法区
与系统相关
pc寄存器（程序计数器）
与系统以及cpu相关
创建一个对象
创建多个对象
数组
Java提供一种容器—>可以存储同一种类型的元素—>数组
数组:必须满足这
些元素数据类型必须是同一种类型!
引用数据类型–>
优点
可以有很多元素
通过动态初始化可以元素赋值
缺点
长度是固定的
必须是连续存储空间
数组的应用
数组的遍历
数组最值问题
数组的基本元素查找
数组高级排序–冒泡排序
默认赋值是int arr=new int[]; 角标值从0开始
创建一个或多个数组对象:
显性赋值
动静态初始化的各个格式
动态初始化
给定数组长度,系统(jvm)默认分配数组元素内容;
格式:
数据类型[] 数组名称 = new 数据类型[数组长度] ;
数据类型 数组名称[] = new 数据类型[数组长度];
举例:
int[] arr = new int[3] ;
在数组如何确定元素的内容
数组名称[索引值(角标值)]:从0开始
静态初始化
给定数组元素,长度由系统给定
原本格式
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,元素3…} ;
数据类型 数组名称[] = new 数据类型[]{元素1,元素2,元素3…} ;
简化版
数据类型[] 数组名称 ={元素1,元素2,元素3…} ;
数据类型 数组名称[] = {元素1,元素2,元素3…} ;
例子 ： int [] arr ={1，2，3}；
arr[0]=1;//[]里的是角标值
arr[1]=2;
arr[1]=3;
注意事项:
不能既动态初始化,又静态初始化(动静结合)
int[] arr = new int[3]{1,2,3} ;//错误
实例：
角标值不能超出数组长度；
数组是引用数据类型 是数据类型 不能为空
null 意思是空的；
[上图的arr=null是空的 输出arr[1]是错误的 因此需要先判断是否为空]
数组的遍历
举例: 数组静态初始化了, int[] arr = {67,53,13,21,87};
需求: 将上面的数组最终以下面格式出现: [元素1, 元素2, 元素3, …]
四种方法
方式1:
方式2
此时的x是角标值！！！
方式3
arr.length 是快速求出数组长度的代码
此时的x是角标值！！！
方式4
数组最值
思路：
先给一个初始值 角标为0的第一个元素为最大，然后和后面的数组元素依次对比，比他大就重新赋值给后面的，依次比较
数组的元素查询
查询输入的数字从0开始因为角标值也是从0数起；
例子1
例子2
例子3
例子3:假设思想
1)定义一个 int index = -1; 找不到
2)遍历arr数组,获取到每一个元素
2.1)判断 arr[x] == target,找到了
2.2)修改index的值(重新赋值) index = x ;
2.3)break;
3)循环一圈都没有找到,
rturn index ;
数组的高级排序（冒泡）
比较次数是数组长度的-1//因为比较的次数最大就是角标值；
基本原理：两两对比 将大的数值往后放 第一次比较会出现最大值
第四天
冒泡排序
比较次数是数组长度-1
两两对比 将大的数值往后放 第一次比较会出现最大值
形式参数问题
方法的形参是基本数据类型，形参的改变不影响实参
方法的形参是引用数据类型，形参的改变会直接影响实参
String 特殊的引用类型 作为参数传递 和基本数据类型形式效果参数一致
面向对象的思想特点
面向过程：
最大特点：我们始终是执行者
买书：–自己攒钱–找书店–找书–买回来
面向对象：
指挥者
买书：找一个懂行的人–找书店–找书–买回来
理念/特征
不断地创建对象，指挥对象取做事情；
Scanner sc=new Scanner(System.in);
面向对象的特征
封装/ 继承/ 多态
面向对象的思想特点
更符合生活中的思想行为习惯
让复杂的事情简单化
让我们从执行者变成指挥者
类
类:
是描述现实世界事物的一组属性和行为的集合!-----> 将事物----定义一个类
事物中属性 成员变量:类中方法外
事物中的行为 成员方法:(去掉static)
show 方法
主方法里建立两个对象 末尾记得加 对象名.show();
类和事物的关系
学生事物
—class student{}
属性：年纪身高体重… 成员变量 在类中，方法外
行为： 学习 … 成员方法(非静态) 去掉static ；和方法定义方法格式一样 study（）；
类和对象/具体事物的关系
事物：一个类型的总称描述具体的事物
学生事物
属性： 姓名年龄性别
行为： 学习
具体事物的代码体现
创建对象格式
类名 对象名=new 类名（）；
例子：Scanner sc=new Scanner(System.in);
对象名.成员变量名=值；（和成员变量类型一致）
对象名.方法名（）；调用方法 展示这个具体事物///如果有返回值,直接使用具体返回值类型接收;没有返回值,直接输出!
有参无返回值类
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-xiuazTXD-1677915356465)(file:///C:\Users\29903\AppData\Local\Temp\ksohtml21988\wps28.jpg)]](https://img-blog.csdnimg.cn/b91dc389ea704b349324c477f41642fb.jpeg)
无参有返回值类型
创建对象内存图解
创建一个对象内存图解/多个对象内存图解
Private修饰
private关键字的特点:
1)被private修饰的成员变量/成员方法(非静态),
只能在本类中访问,外界类不能访问!
2)虽然被私有修饰的成员变量以及成员方法(非静态)不能直接访问,但是
都可以间接的通过"public"公共访问访问!
例子
/*
手机类:
品牌brand,价格price,颜色color—>属性加入私有修饰!
打电话callPhone(),发短信sendMsg()
在PhoneTest中进行 手机类的测试,给属性赋值,并且调用成员方法,打印信息!
(加入this:局部变量给成员变量赋值,局部变量–见名知意)
一个标准类的写法:
类的成员
成员变量:属性私有化
成员方法:公共访问setXXX(xx)/getXXX()
构造方法:无参构造方法:永远给出
有参构造方法
*/
//定义一个手机类
class Phone{
//成员变量
private String brand ;
private int price ;
private String color ;
//无参构造方法
public Phone(){
}
//有参构造方法
public Phone(String brand,int price ,String color){ //"Iphone14",12999,"土豪金"
//局部变量给成员变量赋值
this.brand = brand ;
this.price = price ;
this.color = color ;
}
//setXXX(xx)赋值
public void setBrand(String brand){ //局部变量
this.brand = brand ;
}
public void setPrice(int price){
this.price = price ;
}
public void setColor(String color){
this.color = color ;
}
//getXXX()获取值
public String getBrand(){
return brand ;
}
public int getPrice(){
return price ;
}
public String getColor(){
return color ;
}
}
//测试类
class PhoneTest{
public static void main(String[] args){
//使用 类 对象名 = new 类名() ;
//无参构造方法+setXXX(xx)+getXXX()
Phone p = new Phone() ;
p.setBrand("华为p40") ;
p.setPrice(4599) ;
p.setColor("翡翠绿") ;
System.out.println(p.getBrand()+"---"+p.getPrice()+"---"+
p.getColor()) ;
System.out.println("-----------------------") ;
//方式2:手机类的有参构造方法+getXXX()
/*
public Phone(String brand,int price ,String color){
//局部变量给成员变量赋值
this.brand = brand ;
this.price = price ;
this.color = color ;
}
*/
Phone p2 = new Phone("Iphone14",12999,"土豪金") ;
System.out.println(p2.getBrand()+"---"+p2.getPrice()+"---"+
p2.getColor()) ;
}
}
\###
## **构造方法**
## **定义**
什么是构造方法?
1)方法名和类名一致
2)没有具体返回值类型
3)连void都没有
## **格式和注意事项**
构造方法是可以重载!
构造方法的作用:
给类的成员进行数据初始化!
注意事项:
1)一个类中,如果没有任何构造方法,那么系统(jvm)自动会给我们提供无参构造方法!w
2)一个类中,只提供有参构造方法,那么系统不会无参构造方法,此时,建议我们永远给出无参构造方法!否则,就出现问题!
创建对象的时候固定格式:
类名 对象名 = new 类名() ;
### **例子**
class Student{//学生类
//带两个参数
private String name ;//姓名
private int age ; //年龄
/*
1)方法名和类名一致
2)没有具体返回值类型
3)连void都没有
*/
//无参构造方法
/*
public Student(){
System.out.println("这是Student的无参构造方法") ;
}
*/
//带有一个String类型的参数的构造方法
public Student(String name){ //姓名:局部变量---成员变量
System.out.println("这是一个带有一个String参数的构造方法") ;
this.name = name ;
}
//带有String类型,以及int类型的构造方法
public Student(String name,int age){
System.out.println("这是一个带两个参数的构造方法") ;
}
}
//测试类
class ConstructorDemo{
public static void main(String[] args){
//创建一个学生类对象
Student s = new Student();
System.out.println(s) ;//堆内存地址 无参
System.out.println("-------------------") ;
Student s2 = new Student("高圆圆") ; //一参
System.out.println(s2) ;//新的堆内存空间
System.out.println("-------------------") ;
//在创建第三个学生对象
Student s3 = new Student("高圆圆",44) ;//2个参
System.out.println(s3) ;
}
}
成员变量和局部变量的区别
区别:
1)类中的书写位置不同
成员变量:在类中,方法外
局部变量:在方法定义中或者方法声明上
2)jvm内存位置不同
成员变量:在堆内存中
局部变量:在栈内存中
3)生命周期不同:
成员变量:随着对象的创建而存在,随着对象的创 建完毕并且使用完
等待垃圾回收器回收(不会立即回收)而消失!
局部变量:随着方法调用而存在,随着方法调用结 束而消失
4)初始化值不同:
成员变量:存在系统默认初始化,也可以显示初始 化
局部变量:总之:在使用局部变量之前,必须赋值, 不赋值不行!
例子
class Variable{
//成员变量
int num ; //系统默认初始化就是0
public void show(String y){ //y
//int x = 100 ; //x 局部变量
int x ;
x = 100 ;
System.out.println(x+y) ;
}
}
//测试类
class VariableDemo{
public static void main(String[] args){
//访问show方法
//创建Variable类对象
Variable v = new Variable() ;
System.out.println(v.num) ;
v.num = 100 ;
System.out.println(v.num) ;
v.show("hello") ;
}
}
tem.out.println(s2) ;//新的堆内存空间
System.out.println(“-------------------”) ;
//在创建第三个学生对象
Student s3 = new Student(“高圆圆”,44) ;//2个参
System.out.println(s3) ;
}
}
## **成员变量和局部变量的区别**
区别:
1)类中的书写位置不同
成员变量:在类中,方法外
局部变量:在方法定义中或者方法声明上
2)jvm内存位置不同
成员变量:在堆内存中
局部变量:在栈内存中
3)生命周期不同:
成员变量:随着对象的创建而存在,随着对象的创 建完毕并且使用完
等待垃圾回收器回收(不会立即回收)而消失!
局部变量:随着方法调用而存在,随着方法调用结 束而消失
4)初始化值不同:
成员变量:存在系统默认初始化,也可以显示初始 化
局部变量:总之:在使用局部变量之前,必须赋值, 不赋值不行!
**例子**
```java
class Variable{
//成员变量
int num ; //系统默认初始化就是0
public void show(String y){ //y
//int x = 100 ; //x 局部变量
int x ;
x = 100 ;
System.out.println(x+y) ;
}
}
//测试类
class VariableDemo{
public static void main(String[] args){
//访问show方法
//创建Variable类对象
Variable v = new Variable() ;
System.out.println(v.num) ;
v.num = 100 ;
System.out.println(v.num) ;
v.show("hello") ;
}
}
508
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
