Java基础语法
标识符
- 所有标识符以大小写字母(az，AZ)，美元符号($)，下划线(_)开头
正确命名：
String Ahello = "jdl"; //大小写敏感
String ahello = "jdl";
String $hello = "jdl";
String _hello = "jdl";
错误命名：
String 1hello = "jdl";
String #hello = "jdl";
String *hello = "jdl";
- 不建议用中文，拼音命名
用英文命名更容易阅读
String name = "jdl";
String mignzi = "jdl";
String 名字 = "jdl";
数据类型
-
八大基本类型
btyte 占1个字节 范围：-128~127
short 占2个字节 范围：-32768~32767
int 占4个字节 范围：-2147483648~2147483647
long 占8个字节 范围：-9223372036854775808~9223372036854775807
float 占4个字节 范围：1.4E-45~3.4028235E38
double 占8个字节 范围：4.9E-324~1.7976931348623157E308
char 占2个字节
blooean 占1个字节
//整数类型
byte num2 = 20;
short num3 = 30;
int num1 = 10; //最常用
long num4 = 40L; //Long类型要在数字后面加个L
//小数类型：浮点数
float num5 = 50.1F; //Long类型要在数字后面加个F
double num6 = 3.1415926;
//字符类型
char name1 = '杰';
//字符串，String不是关键字，是类
String name2 = "杰达鲁";
//布尔值：是，非
boolean flag1 = true;
boolean flag2 = false;
- 整数拓展：进制转换
int i1 = 0b10; //二进制0b
int i2 = 10; //十进制
int i3 = 010; //八进制0
int i4 = 0x10; //十六进制0x 0~9 A~F
- 浮点数拓展：浮点数精度有限，最好完全避免使用浮点数进行比较
float f = 0.1f; //0.1
double d = 1.0 / 10; //0.1
System.out.println(f == d); //false
float d1 = 23333333333333333333f;
float d2 = d1 + 1;
System.out.println(d1 == d2);//true
- 字符拓展：所有的字符本质还是数字
char c1 = 'a';
char c2 = '中';
char c3 = 'u0061';
System.out.println(c1); //a
System.out.println((int) c1);//97
System.out.println(c2); //中
System.out.println((int) c2);//20013
System.out.println(c3); //a
类型转换
-
运算中，不同类型的数据先转换成同一类型，再进行运算
低-------------------------------------------------------->高 (浮点数的优先级高于整数)
byte, short, char > int > long > float > double
int i = 128;
byte b = (byte) i; //内存溢出
double d = i;
//强制转换 (类型)变量名 高->低
System.out.println(b); //-128
//自动转换 低->高
System.out.println(d); //128.0
注意点：
- 不能对布尔值进行转换
- 不能把对象类型转换为不相干的类型
- 在把高容量转换到低容量的时候，强制转换
- 转换的时候可能存在内存溢出，或者精度问题！
System.out.println((int) 23.7); //23
System.out.println((int) -45.89f); //-45
char c = 'a';
int c1 = c + 1;
System.out.println(c1); //98
System.out.println((char) c1); //b
//操作比较大的数的时候，注意溢出问题
//JDK7新特性，数字之间可以用下划线分割
int money = 10_0000_0000;
System.out.println(money); //1000000000
int years = 20;
int total = money * years;
System.out.println(total); //-1474836480，计算的时候溢出了
long total1 = money * years;
System.out.println(total1); //-1474836480，total1默认int，转换成long之前就已经存在问题了
long total2 = money * ((long)years);
System.out.println(total2); //20000000000
变量
tpye varName [=value] [{,varName[=value]}];
//数据类型 变量名 = 值; 可以使用逗号隔开声明多个同类型变量
- 不建议在一行声明多个变量
int a, b,c; //不建议这样写
//建议分行设置变量
int a = 1;
int b = 2;
int c = 3;
String name = "jiedalu";
char x = 'X';
double pi = 3.14;
变量作用域
- 类里除了能定义方法，还能定义属性(变量)
- 从属于对象，如果不自行初始化，这个类型的默认值为0或0.0
布尔值：默认是false
除了基本类型，其余的默认值都是null
public class Demo06 {
//类变量 static
static double salary = 2500;
//实例变量
String name;
int age;
//main方法
public static void main(String[] args) {
//局部变量：必须声明和初始化值
int i = 10;
System.out.println(i); //10
//实例变量
//变量类型 变量名字 = new demo08()
Demo06 demo06 = new Demo06();
System.out.println(demo06.age); //0
System.out.println(demo06.name);//nnull
//类变量 static
System.out.println(salary); //2500.0
}
//其他方法
public void add() {
System.out.println();
}
}
常量
- 常量是初始化后不能修改不能变化的值
- 常量名一般用大写字符
public class demo07 {
//修饰符不区分先后顺序
static final double PI = 3.14;
public static void main(String[] args) {
System.out.println(PI); //3.14
}
}
命名规范
- 类变量： 首字母小写，驼峰原则，如：monthSalary，lastName
- 局部变量：首字母小写，驼峰原则
- 常量： 大写字母，下划线 如：MAX_VALUE
- 类名： 首字母大写，驼峰原则
- 方法名： 首字母小写，驼峰原则。如：run()，runRun()
基本运算符
二元运算符
- +，-，*，/
int a = 10;
int b = 20;
System.out.println(a+b); //30
System.out.println(a-b); //-10
System.out.println(a*b); //200
System.out.println(a/(double)b);//0.5
- >，<，==，!=，%
int a = 10;
int b = 20;
int c = 21;
System.out.println(a>b); //false
System.out.println(a<b); //true
System.out.println(a==b);//false
System.out.println(a!=b);//true
//取余，模运算
System.out.println(c%a); //c%a 21/20=2...1
一元运算符
- ++，--
int a = 3;
int b = a++; //执行这段代码后，先给b赋值，再自增
/* 相当于
b = a;
a = a + 1;
*/
System.out.println(a); //4
int c = ++a; //执行这段代码前，先自增，再给c赋值
/* 相当于
a = a + 1;
c = a;
*/
System.out.println(a); //5
System.out.println(b); //3
System.out.println(c); //5
三元运算符
-
? :
x ? y : z
如果x==true，则结果为y，否则结果为z
int score = 80;
String type = score < 60 ? "不及格" : "及格";
System.out.println(type);//及格
逻辑运算符
- && 逻辑与运算 ：两个变量都为真，结果才true
- || 逻辑或运算，两个变量有一个为真，则结果才为true
- ! 如果是真，则变为假，如果是假，则变为真
boolean a = true;
boolean b = false;
System.out.println(b && a); //false
System.out.println(a || b); //true
System.out.println(!(a && b));//true
//短路运算: 与运算时，如果前面为假，则不运算后面的代码
int c = 5;
boolean d = (c<4)&&(c++<4);
System.out.println(d); //false
System.out.println(c); //5
位运算
-
位运算效率极高
-
&，|，^，~
A = 0011 1100
B = 0000 1101
A&B=0000 1100 A和B都是1则为1，否则为0
A|B=0011 1101 A或B是1则为1，否则为0
A^B=0011 0001 A和B相同为0，不同为1
~B =1111 0010 若是1则变为0，若是0则变为1
-
<<左移 *2
-
>>右移 /2
System.out.println(2<<3);//16
0000 0000 0
0000 0001 1
0000 0010 2 //把1左移三位
0000 0011 3
0000 0100 4
0000 1000 8
0001 0000 16 //变成16
扩展赋值运算符
- +=，-=
a+=b; //a = a + b
a-=b; //a = a - b
-
字符串连接符 +
在+号任意一侧若出现了字符串类型(String)，则会把其他操作数都转换成String，再进行连接
int a = 10;
int b = 20;
System.out.println(a+b+""+a+b); //301020
System.out.println(""+a+b); //1020
包机制
- 包机制用于区别类名的命名空间
package pkg1[. pkg2[. pkg3[...]]]
-
一般用公司域名倒置作为包名：com.mooncell.www
-
想要使用包中的成员，需要导入该包，使用"import"语句可完成这个功能
import package1[. package2[...]]. (classname|*)
JavaDoc生成文档
package com.mooncell.base;
/**
* @author Jiedalu
* @version 0.1
* @since 1.8
*/
public class Doc {
String name;
/**
* @author Jiedalu
* @param name
* @return
* @throws Exception
*/
public String test(String name) throws Exception {
return name;
}
}
-
从文件夹打开命令行
-
输入javadoc -encoding UTF-8 -charset UTF-8 Doc.java
javadoc 生成文档
-encoding UTF-8 让编码变为UTF-8格式(用于显示更多中文，减少乱码)
-charset UTF-8 让字符集变为UTF-8格式(用于显示更多中文，减少乱码)
-
打开index.html
