JAVA基础第一周学习总结！小白

最新推荐文章于 2024-07-20 23:55:03 发布

WJZ0805UP

最新推荐文章于 2024-07-20 23:55:03 发布

阅读量193

点赞数

分类专栏： java 文章标签： java

本文链接：https://blog.csdn.net/WJZ0805UP/article/details/107427920

版权

java 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

day1内容

1.关键字

关键字:被Java语言特定含义的单词.
使用notepad++(editplus):高级记事本,针对关键字有特殊颜色标记.
组成关键字的单词:全部都是小写.
class,public, static, void,protected等
class：定义一个类(Java中的最基本的单元)
public:权限修饰符(公开的,公共的）
private(私有的,外界不能直接访问的)
protected:受保护的,权限修饰符
static:静态修饰符 (面向对象部分讲)
void:跟方法有关系(讲解Java中如何定义方法)

注意事项:
	goto,const,这两个单词不是关键字,作为保留字使用!

2.标识符

标识符:给类,(接口),变量,(方法)起名字的字符序列。

 1.给类命名时。（见名知意）

 给类和接口的命名是一样
		如果类的组成是一个单词:首字母大写
			class Hello{}	
			//定义一个学生类   （见名知意）
			
		如果类的组成式多个单词：每个单词首字母都大写（大驼峰命名法）
			class StudentTest{} 针对学生的类测试类
		
 2.给变量(方法)命名是一样的,
		如果变量(方法)是一个单词的话:
			该单词全部小写:
				check() ,方法名
		如果变量或者方法是多个单词的话:
			第一个单词全部小写,从第二个单词开始首字母大写(小驼峰命名法)
				定义方法名:检查用户名
				checkUserName()
				
 3.给常量的命名
		如果是单个单词:
				每个字母都大写
					TYPE 
		如果是多个单词
				每个单词字母大写,中间下划线隔开
					TYPE_TEXT
					
	一般情况:编写代码,要遵循基本规则(开始编码的时候,养成良好习惯!)
	标识符的组成规则:
	1)英文大小写字母
	2)$和下划线_组成					面向对象:内部类 Outer$Inner(后面讲)
	3)数字字符组成
	注意事项:
	1.不能以数字开头(数字字符组成,可以将数字变量的后面)
	2.不能是Java中的关键字
	3.Java是强类型语言,严格区分大小写的

3常量

 常量:在程序的执行过程中,其值不发生改变的量!
	分类:
		1)字面值常量
			a)字符串常量:使用双引号括起来的内容  
				举例: "我爱高圆圆","helloworld..."
			b)字符常量:使用单引号括起来的单个内容
				举例:'A','a','0'	
				'AB':写法有问题
			c)整数常量:		(整数:默认十进制(进制相关的))
				100,1000
			d)小数常量:
				3.14,12.56
			e)布尔常量:
				true,false
			f)空常量:
				null
2)自定义常量。
		
		public static final(终态的,无法更改的,属于状态修饰符) int xxx = xx ;

例如：
class ConstantDemo{
	
	public static void main(String[] args){
		
		//字面值常量
		//字符串常量
		System.out.println("输入数据") ;
		
		//字符常量
		System.out.println('A') ;
		System.out.println('a') ;
		System.out.println('0') ;
		
		//整数常量
		System.out.println(100) ;
		System.out.println(10000) ;
		
		//小数常量
		System.out.println(3.1415926) ;
		//布尔常量
		System.out.println(true) ;
		//空常量null
		//针对引用类型的变量:变量值:默认 null  
		//Java研究的就是引用类型:数据传递问题!
		String str = null ;
		System.out.println(str) ;
    }	
}

day2内容

1变量

变量:程序执行过程中,值发生改变的量!
三要素:
1)数据类型
2)变量名
3)初始化值
针对Java语言数据类型的划分:
两大类:
1 基本数据类型
四类八种
整数类型
byte: 字节类型占1个字节记住byte类型的范围:-128~127(考点)
short:短整型占2个字节
int(整数默认的类型):整数类型占4个字节
long:长整型占8个字节
应用场景:定义时间(系统时间换算成时间毫秒值)相关的变量(都是用long)
浮点类型:(小数默认的就是double类型)
单精度:float类型占4个字节
双精度:double类型占8个字节
字符类型:
char类型占2个字节
布尔类型占1个字节
boolean类型(true/false)
应用场景:用在逻辑判断中,布尔类型一般不参与运算!
2 引用数据类型(研究的这个类型) :面向对象部分讲解数组,类(具体类,抽象类),接口

注意事项::如果定义long类型:在值的末尾加上一个标记(L/l,建议大L)

3 定义变量的注意事项:
1)要遵循的变量的三要素
数据类型变量名 = 初始化值;
2)先定义,但是必须在使用之前对这个变量进行初始化,否则编译不通过!

3)Java是一种强类型,不能重复定义变量

4）同一行上可以定义多个变量,一般我们开发的时候,不建议这样使用(笔试题/面试题)

4 Java中存在强制类型转换:
语法格式:
目标数据类型变量名 = (目标数据类型)(变量值) ;

注意事项:

强制类型不要随便使用,损失数据的精度!

适用范围:基本数据类型以及引用类型!

例1

	class DataTypeDemo4{
	public static void main(String[] args){
		
	//定义两个变量
	int a = 3 ;
	byte b = 4 ;
	
	//目标数据类型  变量名 = (目标数据类型)(变量值) ; 
	byte result = (byte) (a + b) ;-------（目标数据类型  变量名 = (目标数据类型)(变量值) ）
	System.out.println(result) ;
	}
}

例2

	class DataTypeDemo6{
	public static void main(String[] args){
		
	//定义三个变量
	byte b, b1 = 3 ,b2 = 4;
	//b = b1 + b2;//不兼容的类型: 从int转换到byte可能会有损失
	//存在java的隐式类型转换:byte,short,char三者之间不转换,
	//一旦参与运算,对应的类型都先默认提升int.
	
	//使用小的类型来接收大的结果类型, 解决方案:强制类型转换
	//b = (byte)(b1+b2) ;
	//System.out.println(b) ;
	
	b = 3 + 4 ;
	System.out.println(b) ;
	
	}
}

例3

求出 byte b = 130 ;
有问题吗?如果有,如何解决,结果是多少

class DataTypeDemo7{
	public static  void main(String[] args){
		
//-128~127
	//byte b = 130 ;//从int转换到byte可能会有损失
	
	//存在问题:超出了byte类型范围,结果:整数默认int,需要将int--->byte 强制类型转换
	byte b = (byte)130;
	
	System.out.println(b) ;//-126
	}
}

130对应二进制数据是多少:0b10000010

整数默认int:4个字节

130整数的:原码

最高符号位:0 原码,反码,补码都一样
00000000 00000000 00000000 10000010

补码: 计算机底层计算需要用补码进行计算:byte b = (byte)130;
00000000 00000000 00000000 10000010

截取三个字节---->变成一个字节:byte类型

计算后的结果: 10000010 (补码)

最高符号位数值位
1 0000010 补码

1 0000001 反码

负数的反码—>原码:最高符号不变,数值位按位取反,0变1,1变0
1 1111110 原码

结果:

64+32+16+8+4+2

-126

2运算

1.1扩展的算术运算符:

++或者–:
情况1:
单独使用:无论操作符++或者–在数据的前面还是数据的后面,都是对当前数据本身的值进行
自增1或者自减1;

情况2:

参与运算使用:
1)如果++或者–在数据的前面,是先对当前数据值进行自增1或者自减1,然后参与运算
2)如果++或者–在数据的后面,先运算,然后在对该数据值本身进行自增1或者自减1

例：

class OperatorDemo2{
	public static void main(String[] args){
//定义两个变量
	int a = 3 ;
	int b = 4 ;
	System.out.println("a:"+a) ;
	System.out.println("b:"+b) ;
	System.out.println("--------------------------") ;
	
	//单独使用
	//运算符在数据之前(++或者--在数据的前面)
	//++a;
	//--b ;
	//++或者--在数据的后面
	a++ ;
	b--;
	System.out.println("a:"+a) ;
	System.out.println("b:"+b);
	System.out.println("--------------------------") ;
	
	//定义两个变量
	int x = 3 ;
	int y = 4 ;
	System.out.println("x:"+x) ;
	System.out.println("y:"+y) ;
	
	System.out.println("--------------------------") ;
	
	//++或者--参与运算使用
	//1)在数据的前面
	//int m = ++ x ; 
	//int n = -- y ;
	//2)在数据的后面
	int m = x ++ ; //m = x = 3 ;        x ++= 3+1 = 4 ;
	int n = y -- ;//n = y = 4 ;			y -- = 4-1 = 3 ;
	System.out.println("x:"+x) ;
	System.out.println("y:"+y) ;
	System.out.println("m:"+m) ;
	System.out.println("n:"+n) ;
	}	
}

2.2赋值运算：

赋值运算符:
基本的赋值运算符:
=
将等号右边的值赋值给等号左边的变量;
int a = 10 ; 将整数10赋值给int类型的变量a
注意:= 不能写成==(比较运算符)
扩展的赋值运算符
+=,-=,*=,/=,%=…

举例:
+=
将等号左边的数据和右边的数据相加,在赋值给左边的变量
例2

class OperatorDemo{
	public static void main(String[] args){
			
	int a = 10 ;
	int b ; 
	
	b = a = 20 ;//将整数20赋值给变量a,将a结果留下来再赋值给b
	//b = a == 20 ; //将整数20和a的进行比较(不兼容的类型: boolean无法转换为int)
	System.out.println("a:"+a+",b:"+b) ;
	System.out.println("---------------------") ;
	
	int x = 20 ;
	x += 10 ;  //相当于 x = x + 10 ;
	System.out.println(x) ;
	}
}

2.3关系运算符：

关系(比较)运算符
<,>,<=,>=,==,!

特点:使用比较符合连接的表达式无论是简单表达式还是复杂的表达式,结果都是boolean类型

注意:
== 比较的两个数据值是否相等,不要写成= (赋值运算符)

数学表达式: 3<=x<=5
Java语言: x>=3 && x<=5 并列关系

例

class OperatorDemo{
	public static void main(String[] args){
		
//定义三个变量
	int x = 3 ;
	int y = 4 ; 
	int z = 5 ;
	
	System.out.println(x>=y) ;
	System.out.println(x!=z) ;
	System.out.println(y==z) ; //不要写成=
	System.out.println(x<=y) ; //x<y (使用逻辑运算符|  ||) x = y
	
	int m = 10 ;
	int n = 20 ;
	boolean flag =  m==n;
	//boolean flag = m =n; //（不要将==写成"="）
	System.out.println(flag) ;
	
	}
}

2.4逻辑运算符：

逻辑运算符的分类:
基本的逻辑运算符:
逻辑单与 & :有false,则false
逻辑单或 | :有true,则true
逻辑异或 ^ :相同则为false,不同则为true
逻辑非 ! :!true,则false;非false,则true;偶数个非是它本身的结身
开发中,经常使用的逻辑双与&&或者逻辑双或||

扩展的逻辑运算符
逻辑双与 &&
逻辑双或 ||

面试题:
逻辑双与&&和逻辑单与&的区别?

共同点:
		都是并列关系,有false,则false
		
逻辑双与&&最大的不同点:
	存在逻辑双与&&短路效果:    (经常在笔试题中选择题!)
	逻辑双与&&连接的表达式左边如果结果为false,右边的表达式不执行了;

逻辑双|| :逻辑双||连接的表达式左边为true,右边不执行了!(逻辑双||的短路效果)

例：

class OperatorDemo{
public static void main(String[] args){
	
	int a = 3 ;
	int b = 4 ;
	int c = 5 ; 
	
	//逻辑单与 &
	System.out.println((a>b) & (a>c)) ; // flase & flase  = false
	System.out.println((a>b) & (a<c) ) ;//false & true  = false
	System.out.println((a<b) & (a>c) ) ; //true & false = false
	System.out.println((a<b) & (a<c) ) ;//true &  true = true
	System.out.println("----------------------------") ;
	
	//逻辑单或 |
	System.out.println((a>b) | (a>c)) ; // flase | flase  = false
	System.out.println((a>b) | (a<c) ) ;//false | true  = true
	System.out.println((a<b) | (a>c) ) ; //true | false = true
	System.out.println((a<b) | (a<c) ) ;//true | true = true
	
	System.out.println("----------------------------") ;
	//逻辑异或^
	System.out.println((a>b) ^ (a>c)) ; // flase ^ flase  = false
	System.out.println((a>b) ^ (a<c) ) ;//false ^ true  =  true 
	System.out.println((a<b) ^ (a>c) ) ; //true ^ false = true
	System.out.println((a<b) ^ (a<c) ) ;//true ^ true = false
	
	System.out.println("----------------------------") ;
	System.out.println(!(a>b)) ; //!false,则true
	System.out.println(!!(a>b)) ;//false
	}
}

在程序运算中：

	class DataTypeDemo{
	public static void main(String[] args){
	
	//整数类型中的字节类型
	//byte
	byte b = 100 ;
	
	System.out.println("b:"+b) ; //b:值
	System.out.println("---------------------") ;
	
	//short短整型
	short s = 120 ;
	System.out.println("s:"+s) ;
	System.out.println("---------------------") ;
	//int类型(整数默认)
	int i = 10000 ;
	System.out.println("i:"+i) ;
	
	//int ii = 100000000000000; 过大的整数: 100000000000000  
	//整数过大,需要使用长整型定义
	long ii = 100000000000000L ; //注意:如果定义long类型:在值的末尾加上一个标记(L/l,建议大L)
	System.out.println("ii:"+ii) ;
	System.out.println("---------------------") ;
	
	//浮点类型(默认就是double类型)
	//float
	//float f = 12.56 ; //不兼容的类型: 从double转换到float可能会有损失
	//注意:定义浮点类型,它默认double类型,在定义float类型变量,需要在变量值后面加F/f(建议大F)
	float f = 12.56F;
	System.out.println("f:"+f) ;
	System.out.println("---------------------") ;
	double d = 3.1415926;
	System.out.println("d:"+d);
	System.out.println("---------------------") ;
	
	//GBK(中国的中文编码:一个中文对应两个字节)/
	//GB2312(中国的中文编码表:一个中文对应两个字节)
	//UTF-8编码格式(一个中文对应三个字节)
	
	//char类型:字符类型
	char ch = 'A'; 
	char ch1 = 'a' ;
	char ch2 = '0' ;
	System.out.println("ch:"+ch+",ch1:"+ch1+",ch2:"+ch2) ;
	char ch3 = '国' ;
	System.out.println(ch3);
	System.out.println("---------------------") ;
	//布尔类型:用在逻辑判断(真或者假 true/false)
	boolean flag  = false ;
	System.out.println(flag) ;
	flag = true ;
	System.out.println(flag) ;
	//引用类型:面向对象部分说:现在不研究
	
	}
}

day3内容

1 位运算符

位运算符中相关的移动符号:

<<:左移,将最高符号位舍弃掉,在右边补齐0

>>:右移符号: 如果最高符合为如果是0,在左边补齐0;最高符号位如果是1,左边补齐1

>>>:无符号右移:无论最高符号为是0还是1,始终在左边补齐0

	3 << 2 :将3这个数据左移动两位
	计算出3对应的二进制数据:0b11

00000000	00000000	00000000	00000011 原码(同时也是反码和补码,正数)
补码:
	00000000	00000000	00000000	00000011
(00)000000	00000000	00000000	0000001100			(使用补码左移动两位)

000000	00000000	00000000	0000001100:补码--->反码---原码(正数)
=12
24 >> 2 (将24右移2位)

先算出24对应的二进制:0b11000

00000000	00000000	00000000	00011000(正数:原码,反码,补码都相同)

补码
00000000	00000000	00000000	00011000
 (00)00000000	  00000000	  00000000	  000110(00)   (正数:补码--反码--->原码)
  0000000000	  00000000	  00000000	  000110
 结果:6

24 >>> 2
-24的原,反,补
负数
 (原码)
	10000000	00000000	00000000	00011000		
反码:
	11111111	11111111	11111111	11100111
											  +1
	-----------------------------------------------------
补码:
	11111111	11111111	11111111	11101000
	
	
无符号右移
	11111111	11111111	11111111	11101000
	  0011111111	  11111111	  11111111	  111010(00)  
	     -										6
   =-6

结论

//左移符号有一个结论:
//将该符号左边的数据本身乘以2的移动次幂

//右移符号有一个结论:
//将该符号左边的数据本身除以2的移动次幂

2.三元运算符

三元运算符也称为(三目运算符)
三元运算符连接的是两个数值，用于对数据进行判断（大小，相等）
格式:
	(表达式)? 执行true的结果:执行false的结果;
例1：
class OperatorDemo{
public static void main(String[] args){
	
	//定义两个变量
	//需求:求两个数据的最大值
	int a = 100 ;（变量1）
	int b = 200 ;（变量2）
	
	//(表达式)? 执行true的结果:执行false的结果;
	int max = (a >b)? a : b ;
	System.out.println("两个数据的最大值是:"+max) ;

例2：
class OperatorDemo{
public static void main(String[] args){

//比较两个数据是否相等
	
	//定义两个变量
	int m = 10 ;
	int n = 20 ;
	//boolean flag = (m==n)? true :false ;
	//==:比较运算符 :结果就是true或则false
	//优化:改进
	boolean flag = m == n ;
	System.out.println("flag:"+flag) ;
	
例3：
	//求三个数据的最大值
	int x = 50 ;
	int y = 30 ;
	int z = 40 ;
	
	//方式1:使用中间第三方变量进行操作 (开发中常使用:推荐方式)
	//定义中间变量temp
	int temp = (x > y)? x : y ;
	//使用temp和z变量进行比较
	int result = (temp > z)? temp : z ;
	System.out.println("result:"+result) ;
	
	System.out.println("-----------------------") ;
	
	//方式2:直接三元运算符 一步走
	int result2 = (x > y) ?((x>z)? x : z) :((y>z)? y : z) ;
	//int result2 = x > y ?x>z? x : z :y>z? y : z ; // （可以运行但是不建议）去掉括号:阅读性差!
	System.out.println("result2:"+result2) ;

3 键盘录入数据

在之前的学习中,定义变量是写死了,导致程序不灵活;
为了程序的灵活性,引入Scanner类(java.util.Scanner):文本扫描器

键盘录入格式：
1)导包 在Java中只要不是java.lang包下的类都需要导包
	位置在class上面, 格式import java.util.Scanner; (用哪个类导哪个类)
	
2)固定格式:创建一个文件扫描器对象
	Scanner 对象名 = new  Scanner(System.in) ;
	
3)友情提示:"请您输入一个整数数据:"	
4)接收数据:
	int 变量名=  对象名.nextInt() ;
5)输出变量名即可!

例1：

导包

import java.util.Scanner ;
class ScannerDemo{
	public static void main(String[] args){	
//创建键盘录入对象
	Scanner sc = new Scanner(System.in) ;（创建键盘录入对象）
	//提示
	System.out.println("请您输入一个数据:") （提示）
	//接收数据:int类型数据
	int a = sc.nextInt() （接收数据:int类型数据）
	
	System.out.println("a:"+a) ;（输出变量名）

例2：

需求:键盘录入两个数据,求两个数据的最大值
import java.util.Scanner ;
class ScannerTest1{
	public static void main(String[] args){
		
//创建键盘录入对象
	Scanner sc = new Scanner(System.in) ;
	
	//提示
	System.out.println("请您录入第一个数据:") ;
	int a = sc.nextInt() ;
	
	System.out.println("请您录入第二个数据:") ;
	int b = sc.nextInt() ;
	
	//使用三元运算符进行比较
	int max = (a>b) ? a : b ;
	System.out.println("两个数据中的最大值是:"+max) ;

	
	//需求:键盘录入两个数据,比较两个数据是否相等
	System.out.println("输入第一个数据:") ;
	int x = sc.nextInt() ;
	System.out.println("输入第二个数据:") ;
	int y = sc.nextInt() ;
	
	//boolean类型
	boolean flag = (x==y) ;
	System.out.println("flag:"+flag) ;
	
}

}

需求:键盘录入三个数据,求三个数据的最大值
import java.util.Scanner ;
class ScannerTest2{
	public static void main(String[] args){
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		
		//提示并接收数据
		System.out.println("输入第一个数据:") ;
		int num1 = sc.nextInt() ;
		System.out.println("输入第二个数据:") ;
		int num2 = sc.nextInt() ;
		System.out.println("输入第三个数据:") ;
		int num3 = sc.nextInt() ;
		
		//使用中间第三方变量(推荐方式)
		int temp = (num1 >num2)? num1: num2 ;
		//使用temp变量和num3进行比较
		int max = (temp > num3)? temp :num3;
		System.out.println("三个数据中的最大值是:"+max) ;
		System.out.println("-------------------------") ;
		//直接使用三元运算符:一步走
		int max2 = (num1>num2)? ((num1>num3)? num1:num3): ((num2 > num3)? num2 : num3) ;
		System.out.println("三个数据中的最大值是:"+max2) ;
	}
}

4流程控制语句

流程控制语句包括：顺序控制语句，选择控制语句，循环控制语句。

1:顺序结构语句
代码从上到下依次加载!

2:选择结构语句(if 结构语句，switch结构语句)

			
	2.1 if结构语句

			三种格式：

				2.11 if(条件表达式){

						语句;

					}

					
				2.12 if格式2使用居多

					if(条件表达式){

						语句1;

					}else{

						语句2;

					}

					
				2.13 if(条件表达式1){

						语句1;

					}else if(条件表达式2){

						语句2;

						
					.....

					}else{

						语句n+1;

					}

使用If语句的注意事项:

1)有左大括号{的地方不能有分号,有分号的地方不能有左大括号{

2)if语句中如果是单个语句,{}可以省略,但是不建议!

3){}表示一个作用域,定义变量需要在{}这个作用域范围内使用

使用If语句的注意事项:

1)有左大括号{的地方不能有分号,有分号的地方不能有左大括号{

2)if语句中如果是单个语句,{}可以省略,但是不建议!

3){}表示一个作用域,定义变量需要在{}这个作用域范围内使用

例1

	class IfDemo{
	public static void main(String[] args){
	//定义一个变量
	int a = 10 ;
	if(a >=10){ 
		System.out.println("a大于等于10") ;
	}
	//错误写法
	if(a <10);//if语句没有意义:if没有语句体,分号表示一个语句结束
	
	//代码块:局部代码块 :限定变量的生命周期!
	{  
		int x = 10 ;
		System.out.println(x) ;
		System.out.println("a大于等于10") ;
	}
	//System.out.println(x) ; //访问x变量超出了它的作用域范围
	System.out.println("程序结束了...") ;
	    int m = 5 ;    if(m>=5)  //可以省略{},不建议     
        System.out.println("大于等于5") ;
	}
}


if语句中第二种格式用法最多
if语句的格式2:
	
	if(条件表达式){
		语句1;
	}else{
		语句2;
	}
	执行流程:
	1)判断条件表达式是否成立,如果成立,执行语句1
	2)如果不成立,执行语句2;

应用场景:
	针对两种情况进行判断!

三元运算符和if格式2的区别?
三元运算符连接的是两个数据的数据值(针对这个是数据值进行比较或者判断)
if格式2是一种流程控制语句:
范围要比三元运算符大,不仅仅可以判断两个数据数据值还可以操作具体语句

能够使用if格式2实现的不一定能够使用三元运算符;
但是如果能够三元运算符实现的一定能够使用if格式2
(在开发中,针对业务逻辑判断还是使用if格式2)

3.switch语句：

switch 选择结构语句
	格式:
	
	switch(表达式){
	case 值1:
		语句1;
		break ;		
	case 值2: 
		语句2;
		break ;
	...
	...
	default:
		语句n+1;
		break ;
	}

执行流程:
1)switch后面的表达式需要和case语句中的值进行匹配
如果值1匹配了,就执行语句1,遇见break 结束switch语句;
如果值1不匹配,就看值2是否匹配,如果匹配,执行语句2,遇见break结束;
…
如果上面都不匹配,执行default中的语句n+1,break结束语句;

break ; 属于跳转控制语句中一种: “结束,中断” ,
应用场景:是在switch以及loop(循环语句中使用)

switch后面表达式可以是什么样的数据类型?
一般情况:可以byte,short,char,int类型的
JDK5以后,是可以跟枚举 (enum)类型的 (引用类型)
JDK7以后,是可以跟String类型的(引用类型)

*switch语句使用的注意事项:
1)default语句是可以放在语句中的任何位置,不影响执行流程!
(建议default语句使用的时候放在语句末尾)
如果放在语句中,最好带上break,否则会造成case穿透!
2)switch语句的结束条件:
遇见break结束或者程序默认执行到末尾!
3)case语句后面的值只能是常量,不能变量(Java是一种强类型语言)

javascript:前端,简称js,弱类型语言 (switch语句的case后面既可以是常量也可以变量)

例1：

需求:
键盘录入一个数据,判断星期几
1,星期一
2,星期二
…

//导包
import java.util.Scanner;
class SwitchDemo{
	public static void main(String[] args){
	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 ;
		}
	}
}

例

	import java.util.Scanner;
class SwitchDemo3{
	public static void main(String[] args){
		
	//录入一个整数类型,在录入字符串类型(String)
	Scanner sc = new Scanner(System.in) ;
	//接收整数
	int a = sc.nextInt() ;
		//录入字符串
		
	//此时:创建一个新的键盘录入对象
	Scanner sc2 = new Scanner(System.in) ;
	String b = sc2.nextLine() ; //正式的录入字符串:nextLine()

	System.out.println("a:"+a+",b:"+b);
	
	}
}

day4内容

循环结构语句—for

for循环的格式
for(初始化语句;条件表达式;步长语句(控制体语句)){
循环体语句;
}

执行流程:
1)进入for循环,给变量进行初始化,执行初始化语句
2)判断条件表达式是否满足条件 (true的结果),然后执行循环体语句
3)执行循环体完毕之后,执行步长语句(对变量进行操作:++/–)
4)继续判断条件表达式是否成立,如果成立,再次执行循环体语句----->再次执行步长语句
…
…
…
5)当前条件表达式不成立,for语句结束!

求和思想：

求和思想:
		需求:控制台输出1-10之间的和
		
分析:
	0 + 1 = 1 ;
			1 + 2 = 3 ;
					3 + 3 =  6 ;
							 6 + 4 = 10 ;
									  10 + 5 = 15 
												.....
												
	有两个加数:
		第一个加数:是上一次前面数据的所有的和   (定义为一个变量) ：默认从0开始
		第二个加数:数据每次在变化: 1,2,3,4,5,6,...10 (定义变量:for循环中的变量)
		
	求和思想的使用步骤:
		1)定义一个最终结果变量: int sum = 0;
		2)使用循环思想将的数据获取出来(第二个加数)

例：输出1-10之间的和

class ForDemo2{
	public static void main(String[] args){
		
//原始的做法
	System.out.println(1) ;
	System.out.println(2) ;
	System.out.println(3) ;
	System.out.println(4) ;
	System.out.println(5) ;
	System.out.println(6) ;
	System.out.println(7) ;
	System.out.println(8) ;
	System.out.println(9) ;
	System.out.println(10) ;
	System.out.println("-----------------------") ;
	
	//代码重复度高:使用循环
	for(int x = 1 ; x <= 10 ; x++ ){
		System.out.println(x) ; 
	}
	System.out.println("-----------------------") ;
	//原始的做法:
	//需求:控制台输出1-10之间的和
	System.out.println(1+2+3+4+5+6+7+8+9+10) ;
	
	//定义一个最终结果变量
	int sum = 0 ;
	for(int x = 1 ; x <= 10 ; x ++){//x =1 ,1 <=10 , x ++ --->x = 2 , 2 <=10 ,x++ ,--x =3 ,3 <=10 
		
		//sum = sum + x ;
		sum += x ; //使用扩展的赋值运算符
		//0 + 1 = 1 ;
		//1 + 2 = 3 ;
		//3+  3 = 6 ;
		//...
	}
	System.out.println("1-10之间的和是："+sum) ;
	
	}
}

循环结构语句—while

while循环
基本格式

while(条件表达式){
	循环体语句;
	步长语句;
}

扩展格式:(使用居多)
初始化语句 ;
while(条件表达式){
	循环体语句;
	步长语句;
}

执行流程:
1)先执行初始化语句,该变量进行初始化
2)判断条件表达式是否成立,如果成立,先执行循环体语句,----->执行步长语句
3)继续判断条件是否成立,如果还成立,继续在执行循环体语句----->执行步长语句
…
…
最终,条件表达式不成立,while循环结束!

例：

class WhileDemo{
	public static void main(String[] args){
		
//for循环
	for(int x = 1 ; x <= 5; x ++){
		System.out.println("helloworld");
	}
	System.out.println("---------------------");
	//while循环
	int j = 1 ;
	while(j<=5){
		System.out.println("helloworld");
		//步长语句
		j++ ;
		}
	}
}

while循环和for循环的区别?

1)两种循环格式不一样 
	while循环---->
			从内存角度考虑,while循环结束了,依然可以访问循环中的变量(消耗内存空间)
	for循环----->
			从内存角度考虑,for循环结束了,不能访问变量(变量生命周期随着for循环的结束而结束),比较省内存空间
2)从应用场景来说:
	一般情况:如果明确循环次数或者明确循环的范围,优先考虑使用for循环
				举例:给3次机会,模拟用户登录..   可以使用for循环
			
			如果不明确循环次数或者不明确的范围,使用while循环操作 
				举例:	
					猜数字游戏,(产生的随机和用户录入的数据进行比较)
								---->这种情况:使用while循环操作

拓展：

猜数字小游戏

java.lang.Math类:数学运算的类
方法:获取随机数的方法:public static double random() 取值范围:[0.0,1.0)

键盘录入一个数据:整数类型(int) 和随机数据比较,
	如果大了,提示"您录入的数据大了"
	如果小了,提示"您录入的数据小了"
	相等,提示"恭喜您,猜中了"	
	
	附加条件:统计 多少次猜中了


		import java.util.Scanner;
class WhileTest{
	public static void main(String[] args){
		
		//获取一个随机数
	//double d = Math.random() ;
	//System.out.println(d) ;
	//想求出:1-100之间的随机数
	int number = (int)(Math.random()*100+1);   //double
	//System.out.println(number) ;
	while(true){ //不知道录入多少次,使用while死循环
		//创建键盘录入对象
		Scanner sc = new Scanner(System.in) ;
		//提示并接收
		System.out.println("请您输入一个数据:");
		int guessNum = sc.nextInt() ;
		
		//选择结构语句
		if(guessNum > number){
			System.out.println("您录入的数据大了...") ; 
		}else if(guessNum < number){
			System.out.println("您录入的数据小了...") ; 
		}else{
			System.out.println("恭喜您,猜中了...") ;
			break ; //结束循环!  (中断,结束)
			}
		}
	
	}
}

WJZ0805UP

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA基础第一周学习总结！小白

day1内容1.关键字关键字:被Java语言特定含义的单词. 使用notepad++(editplus):高级记事本,针对关键字有特殊颜色标记.组成关键字的单词:全部都是小写.class,public, static, void,protected等class：定义一个类(Java中的最基本的单元)public:权限修饰符(公开的,公共的）private(私有的,外界不能直接访问的)protected:受保护的,权限修饰符static:静态修饰符 (面向对象部分讲)void:跟方法有关
复制链接

扫一扫