重0到1

命令提示符（cmd）

启动： window+r，输入cmd
切换盘符 盘符名称：
进入文件夹 cd 文件夹名称
进入多级文件夹 cd 文件夹1\文件夹2\文件夹3
返回上一级 cd . .
返回根目录 cd
查看当前内容 dir
清屏 cls
退出 exit
// 单行注释
/* */ 多行注释
public class后面代表定义一个类的名称，类是Java当中所有源代码的基本组织单位。
public static void main（String[] agrs）这是万年不变的固定写法，代表main方法 这是代表程序执行的起点。
System.out.println(""); 代表打印输出语句

关键字的特点：

1.完全小写的字母
2.在软件中有特殊颜色。
标识符：在程序中自己定义的内容，比如类的名字、方法的名字和变量的名字。
硬性要求：
不能以数字开头
不能是关键字
软性要求：
类名规范：首字母大写，后面每个单词首字母大写。（大驼峰式）
变量名规范：首字母小写，后面每个单词首字母大写。（小驼峰式）
方法名规范：同变量名。

大写字母A被当作65处理
byte/short/char这三种类型都可以发生数学运算
byte/short/char这三种类型在运算的时候，都会被提升成为int类型，然后再计算。
ASCII码
48 - ‘0’
65 - ‘A’
97 - ‘a’

算数运算符

四则与取模运算

++自增 --自减
四则运算：
加 +
减 -
乘 *
除 / (对于一个整数的表达式来说，除法用的是整除，整数除以整数，结果仍然是整数，只看商，不看余数)
只有对于整数的除法来说，取值运算符才有余数的意义。

取模（取余数）：%

注意事项：一旦运算当中有不同类型的数据，那么结果将会是数据类型范围大的那种

。

public class js{
public static void main(String[] args){
int a=10；
int b=3；
int result1=x/y;
System.out.println(result1);//结果是3

int result2=x%y;
System.out.println(result);//余数 值为1

double result3= x+2.5;//int+double-->double+double-->double
System.out.println(result3);//12.5
}
}

加号的多种用法

四则运算当中的加号“+”有常用的三种方法：
1.对于数值来说，就是加法
2.对于字符char类型来说，在计算之前、char会被提升为int，然后再计算，char类型字符，和int类型数字，之间的对照关系表：ASCII、Unicode
3.对于字符串String（首字母大写，并不是关键字）来说，加号代表字符串连续操作。
任何数据类型和字符串进行连接的时候，结果都会变成字符串

public class Puls{
		public static void main(String[] args){
//字符串类型的变量基本使用
//数据类型 变量名称 =数据值；
String str1 ="Hello";
System.out.println(str1);//Hello
System.out.println("Hello"+"World");//HellowWorld


		String str2="java";
		//String + int -->String
		System.out.println(str2+20);//java20
//优先级问题
System.out.println(str2+20+30);//java2030
System.out.println(str2+(20+30));//java50
}
}

自增自减运算符

自增运算符：++
自减运算符：–
含义：让一个变量涨一个数字1，或者让一个变量降一个数字1
使用格式：写再变量名称之前，或者写在变量名称之后，例如：++num;也可以是num++
使用方式：
1.单独使用：不和其他任何操作混合，自己独立成为一个步骤。
2.混合使用：和其他操作混合，例如和赋值混合，或者与打印操作混合等。
使用区别：
1.在单独使用的时候，前++和后++没有任何区别，也就是num++和++num一样。
2.在混合的时候，有【重大区别】
A.如果是**【前++】，那么变量立刻马上加1，然后拿着结果进行使用。【现加后用】**
B.如果是**【后++】，那么手写使用变量本来的数值，【然后再让变量+1】。【先用后加】**

public class Operator{
	public static void main(String[] args){
	int num1=10;
	++num1;//单独使用，前++
	System.out.println(num1);//11
	num1++;//单独使用，后++
	System.out.println(num1);//12


//与打印操作混合的时候
int num2=20;
//混合使用，先++，变量立刻马上变成21
System.out.println(++num2);//21
System.out.println(num2);//21

int num3=30;
//混合使用，后++，首先使用变量本来的30，然后再让变量+1得到31
System.out.println(num3++);//30
System.out.println(num3);//31

		int num4=40;
		//和赋值操作混合
		int result1=--num4;//混合使用，前--，变量立刻马上-1变成39，将结果交给result1变量
		System.out.println(result1);//39
		System.out.println(num4);//39
		 
		 int num5=50;
		 int result2=num5--;
		 System.out.println(result2);//50
		 System.out.println(num5);//49

int x=10; 
int y=20;
int result3=++x + y--;
System.out.println(result3);//31
System.out.println(x);//11
System.out.println(y);//19

	}
}

赋值运算符

赋值运算符分为：
基本赋值运算符：就是一个等号"=",代表将右侧的数据交给左侧的变量：
int a=30；

复合赋值运算符：
=+ a +=1 相当于 a = a + 1
-= b -=4 相当于 b = b - 4
*= c *=5 相当于 c = c * 5
/= d /=6 相当于 d = d / 6
%= e %=7 相当于 e = e % 7

public class Operator{
	public static void main(String[] args){
	int a = 10;
	a += 5;
	System.out.println(a);//15
	int x=10;
	x %=3;//x= x % 3;x=10%3; x=1;
	System.out.println(x);//1
	}
}

比较运算符

大于： >
小于： <
大于等于: >=
小于等于： <=
相等: == 【两个等号连写才是相等，一个等号代表的是赋值】
不相等: !=

注意事项：
1.比较运算符的结果一定是一个boolean值，成立就是true,不成立就是false
2.如果进行多次判断，不能连着写。
数学中的写法， eg：1<x<3
程序当中【不允许】这种写法

public class Operator{
	public static void main(String[] ages){
	System.out.println(10>5);//true
	 int num1 = 10;
	 int num2 = 12;
	 System.out.println(num1<num2);//true
	 System.out.println(num2>=100);//false
	 System.out.println(num2<=100);//true
	 System.out.println(num2<=12);//true
	


System.out.println(10 == 10);//true
System.out.println(20 != 25);//true
System.out.println(20 != 20);//false


int x = 2;
System.out.println(1<x<3);//错误写法，报错
}
}

逻辑运算符

与（并且） && 全部是true,才是true;否则就是false
或（或者） || 至少一个是true,就是true；全部都是false，才是false
非（取反） ！ 本来是true，变成false;本来是false，变成true

与"&&" ,或"||",具有短路效果：如果根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，从而节省一定的性能。

注意事项：
1、逻辑运算符只能用于boolean值。
2、与、或需要左右各自有一个boolean值，但取反只要有唯一的一个boolean值即可。
3、与、或两种运算符，如果有多个条件，可以连续写：
两个条件： 条件A && 条件B
多个条件：条件A && 条件B && 条件C

public class Logic{
	public static void main(String[] args){
System.out.println(true && false);//false
//true && true-->true
System.out.println(3 < 4 && 10 > 5);//true

System.out.println(true||false);//true;
System.out.println(true||true);//true;
System.out,println(false||false);//false

System.out.println(true);//true
System.out.println(!true);//false

	int a =10;
	//false && ...   后面的不执行了
	System.out.println(3>4 && ++a<100);//false
	System.out.println(a);//10

int b=20;
//true || ...  已经出了结果了 后面的不看了
System.out.println(3<4 || ++b<100);//true
System.out.println(b);//20
	}
}

三元运算符

一元运算符：只需要一个数据就可以进行操作的运算符 eg：取反！、自增++、自减–
二元运算符：需要两个数据才可以进行的操作运算符，eg：加法+、赋值=
三元运算符：需要三个数据才可以进行操作的运算符。
格式：
数据类型 变量名称 = 条件判断 ？ 表达式A ：表达式B；
流程：
首先判断条是否成立：
如果成立为true，那么将表达式A的值赋值给左侧的变量。
如果不成立为false，那么将表达式B的值赋值给左侧的变量；
二者选其一。
注意事项：
1.必须同时保证表达式A和表达式B都符合左侧数据类型的要求。
2.三元运算符的结果必须被使用

public class Operator{
public static void main(String[] ages){

 int a = 10;
 int b = 20;
 //数据类型 变量名称 = 条件判断 ？ 表达式A ：表达式B
 //判断a >b是否成立，如果成立将a的值赋值给max；如果不成立将b的值赋值给max，二者选其一。
 int max = a > b ? a : b;
 System.out.println("最大值:" + max);//20
 
 int result = 3>4 ? 2.5 :10;//类型不统一， 报错
 
 System.out.println(a > b ? a : b);//正确写法
 //a > b ? a : b; 错误写法
}
}