Java初学记录

Java初学上手（小结）

JDK安装，配置环境变量（自行百度）

第一个Java程序

	public class Test14{

	public static void main(String []args){
		
		System.out.println("hello world");
		
		}
	
	}

运行结果（感觉人生巅峰）：

关键字:
被Java语言特定含义的单词。

class,public, static, void,

class:定义一个类(Java中的最基本的单元)
public:权限修饰符(公开的,公共的)(第一周都用public)
	private(私有的,外界不能直接访问的)
	protected:受保护的,权限修饰符
static:静态修饰符 (面向对象部分讲)
void:跟方法有关系(讲解Java中如何定义方法)

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

标识符的组成规则:
	1、英文大小写字母
	2、$和下划线_组成					
	3、数字字符组成
注意事项:
	1、不能以数字开头(数字字符组成,可以将数字变量的后面)
	2、不能是Java中的关键字
	3、Java是强类型语言,严格区分大小写的	

常量:
在程序的执行过程中,其值不发生改变的量!

分类:
	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 ;

变量:
程序执行过程中,值发生改变的量!
三要素:
1)数据类型
2)变量名
3)初始化值

针对Java语言数据类型的划分:
	两大类:
			基本数据类型
					四类八种
						整数类型
							byte: 字节类型				占1个字节  记住byte类型的范围:-128~127(考点)
							short:短整型				占2个字节
							int(整数默认的类型):整数类型   占4个字节
							long:长整型						占8个字节
								应用场景:定义时间(系统时间换算成时间毫秒值)相关的变量(都是用long)
						浮点类型:(小数默认的就是double类型)
							单精度:float类型				占4个字节
							双精度:double类型				占8个字节
						字符类型:		
							char类型						占2个字节
						布尔类型							占1个字节
							boolean类型(true/false)			
							应用场景:用在逻辑判断中,布尔类型一般不参与运算!

运算符：
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、赋值运算符:

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

*/

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) ;
	}
}

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) ;
		
	}
}

4、逻辑运算符：

逻辑运算符的分类:
	基本的逻辑运算符:
		逻辑单与 &  :有false,则false
		逻辑单或 |  :有true,则true
		逻辑异或 ^  :相同则为false,不同则为true
				简单记忆:男女关系
						男男(false)  女女(false)  女男(true) 男女(true)
		逻辑非   !  :!true,则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
	}
}

5、位运算符：

位运算符 :针对两个具体的数据值进行运算

基本的位运算符
	位与&
	位或|
	位异或^
	~反码(按位取反,0变1,1变0)
移动符号
	<<(左移),>>(右移),>>>(无符号右移)

class OperatorDemo{
	public static  void main(String[] args){
		
		System.out.println(3 & 4) ;
		System.out.println(3 | 4) ;
		System.out.println(3 ^ 4) ;	//位异或特点
		System.out.println(~3) ;
	}
}

/*
	位运算--->计算整数的二进制数据
	3 --->二进制 0b11
	4---->二进制 0b100
	
默认int类型(整数)
位与&:有0,则0
3&4
	00000000   00000000		00000000	00000011		3
											 位&
	00000000   00000000		00000000    00000100		4
----------------------------------------------------------
	00000000   00000000		00000000	00000000		
结果:0


3 | 4
位或| :有1,则1

	00000000   00000000		00000000	00000011		3
											 位|
	00000000   00000000		00000000    00000100		4
----------------------------------------------------------
	00000000   00000000		00000000    00000111

	结果:7
	
位异或^:相同则为0,不同则为1


	00000000   00000000		00000000	00000011		3
 位^
	00000000   00000000		00000000    00000100		4
----------------------------------------------------------
	00000000   00000000		00000000    00000111
结果:7


~3:按位取反,0变1,1变0

~  00000000   00000000		00000000	00000011
 ------------------------------------------------
   11111111   11111111      11111111    11111100    (补码)
   
   
   补码---->原码
   
   最高符号位		数值位
	1				1111111   11111111      11111111    11111100  (补码)
															  -1
--------------------------------------------------------------------
	1				1111111	  11111111		11111111 	11111011 (反码)
	
----------------------------------------------------------------------

	1				0000000   00000000      00000000    00000100
	
	-															4
	
	结果:-4

三目运算符：

二目运算符:
int a = 10 ;
int b = 20 ;
	a > b 

三元运算符也称为(三目运算符)

格式:
	(表达式)? 执行true的结果:执行false的结果;

class OperatorDemo{
	
	public static void main(String[] args){
		
		//定义两个变量
		//需求:求两个数据的最大值
		int a = 100 ;
		int b = 200 ;
		
		//定义变量
		//(表达式)? 执行true的结果:执行false的结果;
		int max = (a >b)? a : b ;
		System.out.println("两个数据的最大值是:"+max) ;
		
		System.out.println("-----------------------") ;
		
		
		//比较两个数据是否相等
		
		//定义两个变量
		int m = 10 ;
		int n = 20 ;
		//boolean flag = (m==n)? true :false ;
		//==:比较运算符 :结果就是true或则false
		//优化:改进
		boolean flag = m == n ;
		System.out.println("flag:"+flag) ;
		System.out.println("-----------------------") ;
		
		//求三个数据的最大值
		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) ;
		
	}
}

Scanner类(java.util.Scanner)：
文本扫描器

基本使用:
1)导包 在Java中只要不是java.lang包下的类都需要导包
位置在class上面, 格式import java.util.Scanner; (用哪个类导哪个类)

2)固定格式:创建一个文件扫描器对象
	Scanner 对象名 = new  Scanner(System.in) ;
	
3)友情提示:"请您输入一个整数数据:"	
4)接收数据:
	int 变量名=  对象名.nextInt() ;
5)输出变量名即可!

Scanner类(java.util.Scanner):文本扫描器

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() ;
		
		System.out.println("a:"+a) ;
		//没有说明类型:都是int
	}
}

流程控制语句：

分类：

Java中的流程控制语句:
三大类:
	1)顺序结构语句
		代码从上到下依次加载!
	2)选择结构语句
		if结构语句
			三种格式：
				if(条件表达式){
					语句;
				}
				
				//开发中:if格式2使用居多
				if(条件表达式){
					语句1;
				}else{
					语句2;
				}
				
				if(条件表达式1){
					语句1;
				}else if(条件表达式2){
					语句2;
					
				.....
				}else{
					语句n+1;
				}
				
		switch结构语句
				
	3)循环结构语句

1、if语句的使用：

if格式1:
	if(条件表达式){
		语句;
	}	
执行流程:
1)首先判断条件表达式是否成立,
如果成立,true,就执行语句
否则,不会执行!
应用场景:针对单个条件判断

if语句的格式2:
		
		if(条件表达式){
			语句1;
		}else{
			语句2;
		}
执行流程:
1)判断条件表达式是否成立,如果成立,执行语句1
2)如果不成立,执行语句2;
应用场景:
针对两种情况进行判断!

if格式3:
	if(条件表达式1){
		语句1;
	}else if(条件表达式2){
		语句2;
	...
	
	...
	}else{
		语句n+1;
	}
	
执行流程:
1)先判断条件表达式1是否成立,如果成立,执行语句1;
2)如果条件表达式1不成立,继续判断条件表达式2是否成立,如果成立,执行语句2
3)如果条件表达式2不成立,依次这样判断...
4)如果以上条件都不成立,执行esle中语句n+1;

注意事项：

使用If语句的注意事项:
	1)有左大括号{的地方不能有分号,有分号的地方不能有左大括号{
	2)if语句中如果是单个语句,{}可以省略,但是不建议!
	3){}表示一个作用域,定义变量需要在{}这个作用域范围内使用

2、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后面既可以是常量也可以变量)

举例：

import java.util.Scanner;
class SwitchDemo{
	public static void main(String[] args){
		
		//break ; //单独使用不了; 在 switch 或 loop 外部中断
		//创建键盘录入对象
		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 ;
		}
		
	}
}

循环语句

for循环语句

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

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

while循环语句

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

扩展格式:(使用居多)
初始化语句 ;
while(条件表达式){
	循环体语句;
	步长语句;
}
执行流程:
1)先执行初始化语句,该变量进行初始化
2)判断条件表达式是否成立,如果成立,先执行循环体语句,----->执行步长语句
3)继续判断条件是否成立,如果还成立,继续在执行循环体语句----->执行步长语句
..
...
最终,条件表达式不成立,while循环结束!

举例:输出5次"helloworld"

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++ ;
		}
	}
}