- 变量是什么：就是可以变化的量
- Java是一种强类型语言，每个变量都必须声明其类型
- Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域
type varName [=value] [{,varName[=value]}]
//数据类型 变量名 = 值；可以用逗号隔开来声明多个同类型变量
- 注意事项
- 每个变量都必须有类型，类型可以是基本类型或引用类型
- 变量名必须是合法的标识符
-
变量的声明是一条完整的语句，因此每一个声明都必须以分号结束
-
类变量
- 实例变量
- 局部变量
public class Demo7 {
//属性：变量
//类变量 变量前加上static
static double salary = 9500;
/*
实例变量：从属于对象
如果不自行初始化，一般为这个类型的默认值 如数值类型为0或0.0
布尔类型为false，除了基本类型都是null
*/
String name;
int age;
//main方法
public static void main(String[] args) {
//局部变量：在方法中声明且生命周期只在此方法中 必须声明和初始化值
int i = 10;
//变量类型
Demo7 demo = new Demo7();
System.out.println(demo.age);
System.out.println(demo.name);
//类变量
System.out.println(salary);
}
- 初始化之后不能再更改值！是不会变动的值
- 常量是一种特殊的变量，初始化后，再程序的运行过程中不允许被改变
final 常量名=值；
final double PI=3.14
-
常量名一般使用大写字母
-
所有变量、方法、类型： 见名知意
- 类成员变量：首字母小写和驼峰原则：monthSalary 除了第一个单词之外，后面的单词首字母大写 lastName
- 局部变量：首字母小写和驼峰原则
- 常量：大写字母和下划线：MAX_VALUE
- 类名：首字母大写和驼峰原则：Man，GoodMan
- 方法名：首字母小写和u驼峰原则:run()、runMan()
运算符
Java语言支持如下运算符
- 算式运算符：+，-，/，%，++，–
- 赋值运算符：=
- 关系运算符：>，
- 逻辑运算符：&&
- 位运算符：&，|，^，~，>>，<
- 条件运算符：?，:
- 拓展赋值运算符：+=，-=，*=，/=
public class Demo1 {
public static void main(String[] args) {
//二元运算符
int a = 10;
int b = 20;
int c = 30;
int d = 40;
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println(a/(double)b);
}
}
public class Demo2 {
public static void main(String[] args) {
long a = 234234234234234L;
int b = 23423;
short c = 123;
byte d = 12;
//这里有个知识点 基本类型低容量类型遇到高容量运算 会自动向上转化
System.out.println(a+b+c+d);//Long 类型
System.out.println(b+c+d);//int类型
System.out.println(c+d);//short类型
}
}
public class Demo3 {
public static void main(String[] args) {
//关系运算符返回的结果：false、true
//一般与if配合使用
int a = 10;
int b = 20;
int c = 21;
System.out.println(a>b);
System.out.println(a
a++与++a 结果都是a=a+1,但是会在执行顺序上有一些区别，
a++ 是先执行再自增，++a则相反 先自增再执行
–同理
public class Demo4 {
public static void main(String[] args) {
/*
++自增；--自减 一元运算符
*/
int a = 3;
int b = a++; //执行完这行代码后，先给b赋值，再自增
//相当于此处隐藏了 a = a + 1;
System.out.println(a);
//a = a + 1;
int c = ++a; //执行完这行代码前，先自增，再给b赋值
System.out.println(a);
System.out.println(b);
System.out.println(c);
}
}
//逻辑运算符
public class Demo5 {
public static void main(String[] args) {
//与 &&、或||、非!
boolean a = true;
boolean b = false;
System.out.println("a && b:"+(a && b));//逻辑与运算，两个变量都为真，结果才返回true
System.out.println("a || b:"+(a || b));//逻辑或运算，两个变量有一个为真，结果就返回true
System.out.println("!(a && b):"+!(a && b));//逻辑非运算，如果为真，则返回假，反之 假则返回真
//短路运算 比如 b&&a 由与b是false 下面的a就不需要在判断了 直接结果为false
int c = 5;
boolean d = (c
//逻辑运算符
public class Demo5 {
public static void main(String[] args) {
//与 &&、或||、非!
boolean a = true;
boolean b = false;
System.out.println("a && b:"+(a && b));//逻辑与运算，两个变量都为真，结果才返回true
System.out.println("a || b:"+(a || b));//逻辑或运算，两个变量有一个为真，结果就返回true
System.out.println("!(a && b):"+!(a && b));//逻辑非运算，如果为真，则返回假，反之 假则返回真
//短路运算 比如 b&&a 由与b是false 下面的a就不需要在判断了 直接结果为false
int c = 5;
boolean d = (c
public class Demo6 {
public static void main(String[] args) {
/*
A = 0011 1100
B = 0000 1101
----------------------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~B = 1111 0010
~A = 1100 0011
================================
2*8 = 16 那么如何运算会赠右效率呢？ 答案是使用位运算
<< *2
>> /2
二进制 十进制
0000 0000 0
0000 0010 2
0000 0100 4
0000 1000 8
0001 0000 16
*/
System.out.println(4>>1);
System.out.println(4<
public class Demo7 {
public static void main(String[] args) {
int a = 10;
int b = 20;
a+=b;
System.out.println(a);
a-=b;
System.out.println(a);
//字符串连接符 + ，String
System.out.println(""+a+b); //字符串在前会把后面也转换为字符串
System.out.println(a+b+""); //先计算后转换
}
}
//三元运算符
public class Demo8 {
public static void main(String[] args) {
//x ? y : z 如果x为真，返回y；反之返回z
//也可用if处理
int score = 50;
String res = score
其实运算符有个一优先级的问题（Java优先级是优先级与结合性的综合），但是不用特意去记忆，谨记()最优先足矣
Original: https://www.cnblogs.com/onlyxue/p/16742381.html
Author: 守望在路上
Title: java_day03
原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/573150/
转载文章受原作者版权保护。转载请注明原作者出处！