5，JAVA基础 语法
目录
-
注释、标识符、关键字
-
数据类型
-
类型转换
-
变量、常量
-
运算符
-
包机制、JAVADoc
1，注释、标识符、关键字
书写注释是一个非常好的习惯
单行注释：// 注释
多行注释：/* 注释 */
文档注释：/** 注释 */ 通常和一个命令 JavaDoc结合使用，生成帮助文档，可以添加@等符号
java所有的组成部分都需要名字。类名、变量名及方法名都被称为标识符。
所有的标识符都应该以字母（A-Z或者a-z），美元符（）、或者下划线（）开始；
首字母之后可以 是字母（）、美元符（）、下划线（）、或数字的任何字符组合；
变量或类名可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音。
关键字：
2，数据类型
强类型语言：要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用
Java的数据类型分为两大类：基本类型，引用类型
| 基本数据类型 | 数值类型 | 整数 | byte占1个字节：-128-127 |
|---|---|---|---|
| short占2个字节：-32768-32767 | |||
| 21亿 | int占4个字节：-2147483648-2147483647 | ||
| long占8个字节：-9223372036854775808- | |||
| 9223372036854775807 | |||
| 浮点 | float占4个字节，范围同int | ||
| double占8个字节，范围同long | |||
| 字符 | char占2个字节 | ||
| boolean | 占1位，只有true或false | ||
| 引用数据类型 | 类，接口，数组 |
字符串
String str="Hello Java";//字符串第一种定义方式
String str;
str="Hello Java";//字符串第二种定义方式
变量
每个变量都有类型，类型可以使基本类型或引用类型，变量名必须是合法的标识符。
字节
位（bit）：是计算机内部数据储存的最小单位，11001100是一个八位二进制数
字节（byte）：用B来表示，1B（byte，字节）=8bit（位）
字符：是指计算机中使用的字母、数字、字和符号
public class Demo02 {
public static void main(String[] args) {
String a;
//八大基本数据类型
//整数.输入Integer, Byte等，ctrl左键即可查看大小范围
int num1=10;//最常用
byte num2=20;
short nm3=30;
long num4=30L;//long类型要在数字后面加个L
//小数：浮点数
float num5=50.1f;//float类型要在后面加个F
double num6=3.1415926;
//字符,单引号
char name='A';
char name2='请';//char name3='秦疆';就会报错，字符只能定义单个单位
//字符串,String不是关键字，是类。双引号
String namaa="秦疆";
//布尔值
boolean flag=true;
boolean flag2=false;
//除了基本数据类型之外的都叫引用数据类型
}
}
public class Demo03 {
public static void main(String[] args) {
//整数拓展： 进制 二进制0b 十进制 八进制0 十六进制0x
int i = 10;
int i2 = 010;
int i3 = 0x10;
System.out.println(i);
System.out.println(i2);
System.out.println(i3);//十六进制0x 0-9 A-F
System.out.println("============================================");
//浮点数拓展 银行业务怎么表示？钱
float f = 0.1f;
double d = 1.0 / 10;
System.out.println(f == d);//结果是false
System.out.println(f);
System.out.println(d);
float d1 = 23132332332321232331f;
float d2 = d1 + 1;
System.out.println(d1 == d2);//结果是true
//最好完全避免使用浮点数进行比较！！！
//银行业务可用BigDecimal 数学工具类 用于小数比较
System.out.println("===========================================");
//字符拓展
char c1 = 'a';
char c2 = '中';
System.out.println((int) c1);//强制转换
System.out.println((int) c2);
//所有的字符本质还是数字
//Unicode,2字节，0-65536
char c3 = '\u0061';
System.out.println(c3);
System.out.println("===========================================");
//转移字符
//\t 制表符，\n 换行
System.out.println("===========================================");
String sa = new String("hello world");
String sb = new String("hello world");
System.out.println(sa == sb);//false
String sc = "hello world";
String sd = "hello world";
System.out.println(sc == sd);//true，new会新建一个内存空间
System.out.println("===========================================");
//布尔值拓展
boolean flag = true;
if (flag == true) { }
if (flag) { }//这两组代码意思一样，less is more，代码要精简易读。
}
}
3，类型转换
容量由低到高：byte, short, char, int, long, float, double，运算中，不同类型的数据先转化为同一类型，然后进行运算。
强制类型转换
自动类型转换
public class Demo04 {
public static void main(String[] args) {
int i=128;
byte b=(byte)i;
System.out.println(i);//128
System.out.println(b);//-128，内存溢出
//强制转换 （类名）变量名 高-低
double c=i;
System.out.println(c);//128.0
//自动转换 低-高
/*
注意点：
1，不能对布尔值进行转换
2，不能把对象类型转换成不相干的类型
3，在把高容量转换到低容量的时候，强制转换
4，转换的时候可能存在内存溢出，或是精度问题
*/
System.out.println("=======================================");
System.out.println((int)23.7);//23
System.out.println((int)-45.89f);//-45
System.out.println("=======================================");
char c1='a';
int d=c1+1;
System.out.println(d);//98
System.out.println((char)d);//b
System.out.println("=======================================");
//操作比较大的数的时候，注意溢出问题
int money=10_0000_0000;
int years=20;
int total=money*years;
System.out.println(total);//-1474836480
long total2=money*years;//结果默认为int类型，容量已经超出了
System.out.println(total2);//-1474836480
long total3=money*((long)years);
System.out.println(total3);//20000000000
}
}
4，变量和常量
变量：每个变量都有类型，类型可以是基本类型或引用类型，变量名必须是合法的标识符。变量申明是一条完整的语句，因此每一个声明都必须以分号结束。其要素包括变量名，变量类型和作用域。依据变量的作用域可将变量分为类变量，实例变量和局部变量。
public class Variable{
static int allClicks=0; //类变量，关键词static
String str ="hello world";//实例变量，方法外面类里面
public void method(){
int i=0; //局部变量，在方法里
}
}
public class Demo06 {
//类变量 static
static double salary=2500;
//实例变量：从属于对象,如果不自行初始化，这个类型的默认值通常为0或0.0
//布尔值默认值是false;
//除了基本类型，其余的默认值都是null；
String name;
int age;
//main方法
public static void main(String[] args) {
//局部变量：必须声明和初始化值,作用范围即这个中括号中
int i=10;
System.out.println(i);
//变量类型 变量名字=new Demo08();
Demo06 demo06 = new Demo06();
System.out.println(demo06.age);
System.out.println(demo06.name);
//类变量 static
System.out.println(salary);
}
//其他方法
public void add(){
}
}
常量（Constant）：初始化（initialize）后不能在改变值，不会变动的值，可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。常量明一般使用大写字符。
final 常量名=值;
final double PI=3.14;
public class Demo09 {
//变量类型前的限定词为修饰符，不存在先后顺序，static final或final static都可
static final double PI=3.14;
public static void main(String[] args) {
System.out.println(PI);
}
}
变量的命名规范
-
所有变量、方法、类名：见名知意
-
类成员变量：首字母小写和驼峰原则：monthSalary，除首单词以外的单词首字母大写
-
局部变量：首字母小写和驼峰原则
-
常量：大写字母和下划线：MAX_VALUE
-
类名：首字母大写和驼峰原则：Man, GoodMan
-
方法名：首字母小写和驼峰原则：run(), runRun()
5，运算符
-
算数运算符：+,-,*,/,%,++,--
-
赋值运算符：=
-
关系运算符：>,<,>=,<=,==,!=,instanceof
-
逻辑运算符：&&,||,!
-
位运算符：&,|,^,~,>>,<<,>>>
-
条件运算符：？,:
-
扩展赋值运算符：+=,-=,*=,/=
//算数运算符
package operator;
public class Demo01 {
public static void main(String[] args) {
//ctrl+D是复制当前行到下一行。
int a=10;
int b=20;
System.out.println(a/b);//0
System.out.println(a/(double)b);//0.5
System.out.println("===================================================");
int c=1212121211;
int d=123;
short e=10;
byte f=8;
System.out.println(c+d+e+f);//有long类型，结果为long类型
System.out.println(d+e+f);//int
System.out.println(e+f);//int
//结果依据容量大小输出，优先级为double,long,int
}
}
package operator;
public class Demo02 {
public static void main(String[] args) {
int a=3;
int b=a++;//先将a赋值给b，在自加，所以b=3,a=4,
int c=++a;//先自加，在赋值给c，所以a=5，c=5
System.out.println(a);
System.out.println(b);
System.out.println(c);
//幂运算
double pow = Math.pow(2, 3);
System.out.println(pow);
}
}
package operator;
//位运算符
一.原码
1>.正数的原码就是它的本身
假设使用一个字节存储整数，整数10的原码是：0000 1010
2>.负数用最高位是1表示负数
假设使用一个字节存储整数，整数-10的原码是：1000 1010
二.反码
1>.正数的反码跟原码一样
假设使用一个字节存储整数，整数10的反码是：0000 1010
2>.负数的反码是负数的原码按位取反（0变1,1变0），符号位不变
假设使用一个字节存储整数，整数-10的反码是：1111 0101
三.补码（再次强调，整数的补码才是在计算机中的存储形式。）
1>.正数的补码和原码一样
假设使用一个字节存储整数，整数10的补码是：0000 1010（第三次强调：这一串是10这个整数在计算机中存储形式）
2>.负数的补码是负数的反码加1
假设使用一个字节存储整数，整数-10的补码是：1111 0110（第三次强调：这一串是-10这个整数在计算机中存储形式）
正数原码反码补码一样
负数反码减一取反得原码，符号位在这个过程中始终不变
public class Demo06 {
public static void main(String[] args) {
/*
A=00111100
B=00001101
A&B 00001100 双1得1，除此以外都为0
A|B 00111101 有1为1
A^B 00110001 相同为0，相异为1
~B 11110010 取反
<<左移，左移一位相当于乘2
>>右移，右移一位相当于除2，位运算效率极高
0000 0000 0
0000 0001 1
0000 0010 2
0000 0100 4
0000 1000 8
0001 0000 16
*/
System.out.println(2<<3);//结果等于16
}
}
package operator;
//逻辑运算符
public class Demo05 {
public static void main(String[] args) {
//与&&（and） 或||（or） 非!（取反）
boolean a=true;
boolean b=false;
System.out.println("a&&b"+(a&&b));//false
System.out.println("a||b"+(a||b));//true
System.out.println("!(a&&b)"+!(a&&b));//true
}
}
package operator;
//扩展赋值运算符
public class Demo07 {
public static void main(String[] args) {
int a=10;
int b=20;
a+=b;//a=a+b; a-=b同a=a-b
System.out.println(a);//30
//字符串连接符 +
System.out.println(a+b);//50
System.out.println(""+a+b);//3020
System.out.println(a+b+"");//50
}
}
package operator;
//三元运算符
public class Demo08 {
public static void main(String[] args) {
//x?y:z
//如果x==true,结果为y，否则结果为z
int score=80;
String type=score <60?"不及格":"及格";
System.out.println(type);
}
}
优先级：
6，包机制
为了更好的组织类，JAVA提供了包机制，用于区别类名的命名空间。
包语句的语法格式为
package pkg1[. pkg2[. pkg3...]];
package com.kuang.operator;
一般利用公司域名倒置作为包名；
为了能够是用某一个包的成员，我们需要在JAVA程序中明确导入该包，使用“import”语句可完成此功能。
import package1[.package2...].(classname|*);
import com.kuang.base.Demo01;
import com.kuang.base.*//引入这个包下所有的类
搜索“阿里巴巴JAVA开发手册”
浙公网安备 33010602011771号