-
类变量
-
实例变量
-
局部变量
public class Demo{
//类变量 static
static double money=3000；//3000默认类型是int，double的优先级高，直自动转换
//类变量从属于Demo类，会随着Demo类存在和消失
//============================================================================
//实例变量，在方法的外面，在类（Demo）的里面，从属于对象（类Demo），通过这个类（Demo)才能使用实例变量，级别较高
String name；
int age；//实例变量可以不用初始化，可直接使用
//实例变量如果不进行初始化，变量储存这个类型的默认值
//所有的数值类型的默认值都是0（整数）,0.0（小数），布尔值默认值是false，除了基本类型，其余数据类型的默认值都是null（String类型的默认值就是 //（null）
//============================================================================
//main方法，局部变量
public static void main(String[] args){
//方法里面的变量是局部变量，作用域只有这个（main）方法，使用之前必须声明和初始化值
int i=10;//此处必须赋初值，否则下面就不能输出
System.out.println(i);
//变量类型 变量名=new Demo()
Demo demo=new Demo();//使用类里面的实例变量，首先要把它的类拿过来，就是new一下，定义一个Demo类型的变量demo
System.out.println(demo.age);
//类变量
System.out.println(money);//类变量可以直接输出
}
}常量
public class Demo1{
//static和final都是修饰符。修饰符不存在先后顺序
static final double PI=3.14159;//加了static就变成了类常量，可直接在方法里面使用
//final static double PI=3.14159;
public static void main（String[] args）{
System.out.ptintln(PI);
}
}
变量的命名规范：
所有变量、方法和类名要做到“见名知意”
类成员变量：首字母小写和驼峰原则：除了第一个单词以外，后面单词的首字母大写，eg：monthSalary
局部变量：首字母小写和驼峰原则
常量：所有字母大写，多个单词使用下划线隔开，eg：MAX_VALUE
类名：首字母大写和驼峰原则，eg：Man，IronMan
方法名：首字母小写和驼峰原则，eg：run()，runRun()；
算术运算符：
-
注意算术运算过程中，由于数据类型运算产生的运算错误
public class Demo{
public static void main(String[] args){
int a=10;
int b=20;
System.out.println(a/b);//这里输出的结果是0，因为10/20=0.5，int类型运算之后还是int类型，所以直接就把0.5的小数位舍去了。
System.out.println(a/(double)b);//只用把其中一个运算项强制转换成浮点型即可。
}
}
-
程序实例
public class Demo{
public static void main(String[] args){
long a=10;
int b=10;
short c=10;
byte d=1;
System.out.println(a+b+c+d);//注意：基本运算中有一个数据类型是long，那么运算结果就是long类型
System.out.println(b+c+d);//如果没有long类型的那么操作结果就是int类型
System.out.println(c+d);
}
}
-
总结以上现象就是，基本运算中如果有一个是高优先级的数据类型，那么运算结果就是这个高优先级的数据类型，总之就是以最高的优先级为准
关系运算符
public class Demo{
public static void main(String[] args){
//关系运算符返回的结果只有：正确true，错误false，所以要用布尔值表示
int a=10;
int b=20;
int c=15;
System.out.println(a>b);//输出结果是：true
System.out.println(a<b);//false
System.out.println(a==b);//false
System.out.println(a!=b);//true
System.out.println(c%a);//取余%，也叫模运算， 15/10=1....5，所以输出结果就是5
}
}
自增++、自减--
++，--是一元运算符，只用一个变量即可操作
public class Demo{
public static void main(String[] args){
int a=1;
int b=a++;//++在变量后面，就是先执行赋值（=）运算，然后再执行自加运算
System.out.println(a);//所以此时输出的,b的值是1，a的值是2
int c=++a;//++在变量前面，就是先执行自加运算，然后再执行赋值（=）运算
System.out.println(a);//此时输出的a的值是3
System.out.println(b);//此时输出的b的值是1
System.out.println(c);//此时输出的a的值是3
//同样，--操作同理
//在java中没有幂运算符，而是使用专门的Math类完成数学计算
double pow=Math.pow(2,3);//使用Math类里面的pow函数进行次方的计算
System.out.println(pow);
}
}
逻辑运算符
public class Demo{
public static void main(String[] args){
//与或非
boolean a=true;
boolean b=false;
System.out.println("a&&b:"+(a&&b));//双引号里面的内容是直接输出，使用加号+表示和后面的内容连在一起，(a&&b)运算要使用括号，不然会报错
System.out.println("a||b:"+(a||b));
System.out.println("!(a&&b):"+!(a&&b));//逻辑非就是把逻辑与取反
//短路现象
/*
我们知道a&&b的结果肯定是false，但是b&&a的结果是多少？
当程序在执行b&&a的时候，因为b=false，那么不管后面是真是假，逻辑与的结果肯定是假，所以程序直接就不在执行后面的语句，直接输出false，如下：
*/
System.out.println("a&&b:"+(a&&b));
}
}
位运算
public class Demo{
public static void main(String[] args){
/*位运算：按位与、或、非
A=0011 0110
B=1010 0011
A&B=0010 0010
A|B=1011 0111
A^B=1001 0101//异或：相同为零，不同为一
~B=0101 1100
右移>> 左移<<
//计算2*8=16=2*2*2*2
0000 0000 0
0000 0001 1
0000 0010 2
0000 0011 3
0000 0100 4
0000 1000 8
0001 0000 16
观察发现，二进制数最低位的1每向左移一位，十进制数就增大二倍
那么，左移<< *2.右移>> /2
*/
}
}
扩展赋值运算符
public class Demo{
public static void main(String[] args){
int a=1;
int b=2;
a+=b;//a=a+b;
a-=b;//a=a-b;
//字符串连接符 +
System.out.prnitln(""+a+b);
//此时的输出结果是1020，因为java的规则中，加号运算符任何一端出现了字符串类型（String），输出结果会自动转换成字符串类型并连接在一起
System.out.println(a+b+"");
//此时输出的是30，why？这跟上面的不冲突，涉及到运算先后顺序问题，这里是String类型字符串在后面，实际上先进行a+b运算，然后再跟""进行拼接
}
}
三元运算符
public class Demo{
public static void main(String[] args){
//x ? y : z
//如果x==true,返回结果是y，如果x==false，返回结果是z
int score=95;
String type=score>60? "pass" : "reject"
System.out.println(type);//输出结果：pass
}
}
如何在一个project中建立多个package
