单行注释 // 注释一行文字
多行注释 /* 注释一段文字 */
文档注释 /** 可以读取的注释 */ /** 特殊多行注释 */ 书写注释是个非常好的习惯 养成标准的注释习惯
标识符 + 名字 = 赋予的值
| 1 | 2 | 3 | 4 | 5 |
|---|---|---|---|---|
| abstract | assert | boolean | break | byte |
| case | catch | char | class | const |
| continue | default | do | double | else |
| enum | extends | final | finally | float |
| for | goto | if | implements | import |
| instanceof | int | interface | long | native |
| new | package | private | protected | public |
| return | strictfp | short | static | super |
| switch | synchronized | this | throw | throws |
| transient | try | void | volatile | while |
// Java 所有的组成部分都需要名字。类名、变量名以及方法名都被成为标识
所有标识符都应该为字母（A-Z或者a-z） 美元符（$） 下划线（_）开始
首字符之后可以是字母（A-Z或者a-z）美元符（$）下划线（_）或数字的任何字符组合
不能使用关键字作为变量名或方法名
标识符大小写敏感的
合法标识举例：age Ssalary _value __1_value
非法标识举例：1name /name #name
要求变量的使用要严格符合规定 所有变量都必须先定义后才能被使用
安全性高 速度较慢
byte 占1个字节范围：-128 - 127
short 占2个字节范围：-32768 - 32767
int占 4个字节范围：-2147483648 - 2147483647
long 占8个字节范围：-9223372036854775808 - 9223372036854775807
float 占4个字节
// float 的数值后面要加大写F
double 占8个字节
char 占2个字符
// boolean类型 占1位其值只有 true 和 False 两个
public class Demo02 {
public static void main(String[] args) {
//八大数据类型
byte a = 10;
short b = 20;
int c = 30;
long d = 40L;
// long的数值后面加大写L
//小数 浮点数
float e = 2.1F;// float的数值后面要加大写F
double f = 3.1415926;
//字符
char g = ‘丘‘;
//string name = "丘山";
//string 不是关键字 是‘类’
//布尔值 是非
boolean h = true;
String K = "qiushan";
int now = 100;
System.out.println(a);
System.out.println(now);
}
}
// 不是基本数据类型的都是 引用数据类型
低 ====================================高
byte , short , char => int => long => float => double
强制转换 （类型）变量名 高 -- 低
不能对布尔值进行转换
不能把对象转换为不相干的类型
把高容量的转换为低容量的时候，强制转换反之自动转换
转换的时候可能存在内存溢出，或者精度问题
自动转换 低 -- 高
public class Demo04 {
public static void main(String[] args) {
int a = 128;
double b = a;
System.out.println(a);
System.out.println(b);
/*
不能对布尔值进行转换
不能把对象转换为不相干的类型
把高容量的转换为低容量的时候，强制转换反之自动转换
转换的时候可能存在内存溢出，或者精度问题
*/
System.out.println("===========================");
System.out.println((int)23.75); // 23
System.out.println((int)-28.45); // -28
System.out.println("=======================");
char q = ‘A‘;
int w = q + 1;
System.out.println((int)q);
System.out.println(w);
System.out.println((char)w);
?
System.out.println("=======================");
//跨度比较大的时候 注意溢出问题
//数字之间可以用下划线
int money = 1_000_000_000;
int years = 20;
System.out.println(money * (long)years);
}
}
变量是什么：就是可以变化的量！
Java是一种强类型语言，每个变量都必须生命其类型
Java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域
type varName [ = value ] [{,varname[ = value ]}];
//数据类型 变量名 = 值：可以使用逗号隔开声明多个同类型变量。
注意事项
每个变量都有类型，类型可以是基本类型，也可以是引用类型。
变量名必须是合法的标识符
变量声明是一条完整的语句，因此每一个声明都必须分号结束
类变量
public class Demo06 {
//类变量 static
static double salary =2500;
public static void main(String[] args) {
//类变量 static
System.out.println(salary);
}
}
实例变量
public class Demo06 {
String name;
int age;
public static void main(String[] args) {
//变量类型 变量名称 = new Demo06()
Demo06 demo06 = new Demo06();
System.out.println(demo06.name);
System.out.println(demo06.age);
}
}
局部变量
public class Demo06 {
public static void main(String[] args) {
//局部变量 必须声明初始化值
int i = 10;
System.out.println(i);
}
}
常量：初始化后不能改变值！不回变动的值
所谓常量可以理解成一种特殊变量，它的值被设定后，在程序运行过程中不允许被改变
final 常量名 = 值；
final double PI = 3.14；
常量名一般使用大写字符
public class Demo07 {
//修饰符不存在先后顺序
static final double PI = 3.14;
?
public static void main(String[] args) {
System.out.println(PI);
}
}
变量的命名规范
所有变量、方法、类名：见明如意
类成员变量：首字母小写和托福原理：monthSalary
//除了第一个单词以外首字母大写 lastName
局部变量：首字母小写和驼峰原理
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原理：Man，GoodMan
方法名：首字母小写和驼峰原理：run(),runRUN()
| 名称 | 运算符 |
|---|---|
| 算术运算符 | +，-，*，/，%，++，-- |
| 赋值运算符 | = |
| 关系运算符 | >，<，<==，>==，==，！=，instanceof |
| 逻辑运算符 | &&，||，! |
| 位运算符 | &，|，^，~，>>，<<，>>> |
| 条件运算符 | ？，： |
| 扩展赋值运算符 | +=，-=，*=，/= |
算数运算符
public class Demo02 {
public static void main(String[] args) {
//++ -- 自增，自减，一元运算符
int a = 3;
int b = a++;//执行完这行代码后先给b赋值再自增
//a = a + 1
int c = ++a;//执行完这行代码后先给c赋值再自增
//a = a + 1
System.out.println(a);
System.out.println(b);
System.out.println(c);
//幂运算 2^3 2*2*2 = 8 很多运算会是使用工具类
double pow = Math.pow(2,4);
System.out.println(pow);
}
}
逻辑运算符
public class Demo03 {
public static void main(String[] args) {
// 与 (and) 或 (or) 非(取反)
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));//如果为真则为假，如果为假则为真
//短路运算测试
int c = 5;
boolean d = (c<4)&&(c++<4);//先后运算 前者为false 后者不进行运算
System.out.println(d);
System.out.println(c);
}
}
位运算符
package operator;
?
public class Demo04 {
public static void main(String[] args) {
//位运算符
/*
A = 1100 1100
B = 0000 1101
A&B 0000 1101
A|B 1100 1101
A^B 1100 0001
~B 1111 0010
效率巨高
2*8 2*2*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
*/
System.out.println(2<<3);//16
}
}
三元运算符
public class Demo06 {
public static void main(String[] args) {
// x ? y : z
//如果x==true，则结果为y，否则结果为z
?
int score = 80;
String type = score <60 ?"不及格":"及格";
// if
System.out.println(type);
}
}
运算优先级
()
! ~ ++ --
* / %
+ -
<< >> >>>
&
|
+= -= *= /=
字符连接符
public class Demo05 {
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);
?
//字符串连接符 + string
System.out.println(""+a+b);//""号后面的字符串连接
System.out.println(a+b+"");//“”前面的正常运算
?
String s1 = "Hello";
String s2 = "world";
String s = s1 + " " + s2 + "!";
System.out.println(s);//""加在中间连接字符串
}
}
包的本质就是文件夹
为了更好地组织类，Jva提供了包机制，用于区别类型的命名空间
包语句的语法格式为
package pkg1[.pkg[.pkg3...]];
一般利用公司域名倒置作为包名
为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用“import”语句可完成此功能
import package1.[.package2...].(classname|*)；
Javadoc命令是用来生成自己API文档的
参数信息
@author 作者名
@version 版本号
@since 指明需要最早使用的jdk版本
param 参数名
return 返回值情况
throws 异常抛出情况
将java编译成文档 javadoc -encoding UTF-8 charset UTF-8 doc.java
原文：https://www.cnblogs.com/Qiu101Shan/p/15177053.html