1、注释、标识符、关键字
（1）注释
单行注释：//
多行注释：/* 文字 */
文档注释（Java Doc）：/**
*@Description
*@Author
*/
(有趣的代码注释)
（2）标识符
类名、变量名以及方法名都被称为标识符。
-
所有的标识符都应该以字母（A-Z或者a-z），美元符（$）、或者下划线（_）开始
-
首字符之后可以是字母（A-Z或者a-z）、美元符($)、下划线（_）或者数字的任何字符组合。
-
不能使用关键字作为变量名或方法名。
-
标识符是大小写敏感的。
-
合法标识符举例：age、$salary、_value、__1_value........
-
非法标识符举例：13abc、-salary、#www
-
可以使用中文命名，但是一般不建议使用，也不建议拼音。
（3）关键字
| 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 |
2、数据类型
（1）强类型语言（Java）：安全性高、速度慢
所有变量都必须先定义后才能使用，必须为每一个变量声明一种类型。
（2）弱类型语言（VB、JS）
（3）Java的数据类型分为两大类
-
基本类型
-
不能用如下代码检测一个特定值是否等于Double.NaN:
if(x == Double.NaN) //is never true所有“非数值”的值都认为是不相同的，但是，可以使用Double.isNaN方法：
if(Double.isNaN(x)) //check weather x is "not a number" -
引用类型：类、接口、数组。
-
public class Demo02 { public static void main(String[] args) { //八大基本类型 //整数 int num1=111; //最常用 byte num2=127; short num3=333; long num4=444L; //long类型要在后面加个L //小数：浮点数 float num5=123.6F; //float类型要在后面加个F double num6=11122233344555.666777; //字符 char name7='E'; //字符串，String不是关键字，而是类 // String name2="wff"; //boolean布尔值 boolean answer8=true; // boolean answer=false; } }
对应的类：
int--integer、byte--Byte......
-
位（bit）：是计算机内部数据存储的最小单位，11100101是一个八位二进制；
-
字节（byte）：是计算机数据处理的基本单位，用B表示;
-
字符：是指计算机中使用的字母、数字、字和符号；
-
1B=8bit ； 1024B=1KB ; 1024KB=1MB ; 1024MB=1G;
数据类型拓展及面试题讲解
public class Demo03 { public static void main(String[] args) { //整数拓展 进制 二进制0b 十进制 八进制0 十六进制0x int i=10; int i2=010; //八进制0 int i3=0x10; //十六进制0x System.out.println(i); System.out.println(i2); System.out.println(i3); System.out.println("=============================================="); //浮点数拓展 银行业务怎么表示？ //BigDecimal 数学工具类 //float 有限 离散 舍入误差 大约 接近但不等于 //double //最好完全使用浮点数进行比较 float f=0.1f; double d=1.0/10; System.out.println(f==d); float d1=41498696786987676f; float d2=d1+2; System.out.println(d1==d2); //字符拓展 char c1='q'; char c2='r'; System.out.println(c1); System.out.println((int)c1);//强制转换 System.out.println(c2); System.out.println((int)c2);//强制转换 //所有的字符本质还是数字 //编码 Unicode 表：97=a 65=A 2字节 0-65536 Excel 2^16=65536 char c3='\u0088'; System.out.println(c3); //转义字符 // \t 制表符 // \n 换行 System.out.println("wwwww\tuuuuu"); //引用类型比较的是地址 //布尔值扩展 boolean flag=true; if(flag==true){} if(flag){} //效果一样，下面更简单易读 } }
3、类型转换
因为Java是强类型语言，在进行部分运算时，需要用到类型转换。
低---------------------->高
byte,short,char->int->long->float->double
运算时，不同类型会转化为同一类型进行计算。
public class Demo04 {
public static void main(String[] args) {
int i=128;
byte b=(byte)i; //内存溢出
double c=i;
//强制转换 （类型）变量名 高-》低
//自动转换 低--》高
System.out.println(i);
System.out.println(b);
System.out.println(c);
/*注意点
1、不能对布尔值进行转换
2、不能把对象类型转换为不相干的类型
3、在把高容量转换到低容量时，强制转换
4、转换的时候可能会出现内存溢出或者精度问题
*/
System.out.println("=================");
System.out.println((int)66.8);
System.out.println((int)-66.6f); //精度丢失
System.out.println("===================");
char d='a';
int e=d+1;
System.out.println(e);
System.out.println((char) e);
}
}public class Demo05 {
public static void main(String[] args) {
//操作比较大的数时，需要注意溢出问题
//JDK7新特性，数字之间可以用下划线分割
int num1=10_0000_0000;
int num2=20;
int total1=num1*num2; //溢出
long total2=num1*num2; //溢出,默认是int，先计算后转换，转换之前已经存在问题！！！
System.out.println(num1);
long total3=num1*((long)num2);
System.out.println(total3);
}
}
4、变量、常量、作用域
（1）变量
-
Java是一种强类型语言，每个变量都必须声明类型。
-
Java变量是程序中最基本的存储单元，其要素包括变量名、变量类型和作用域。
type varName [=value][{,varName[=value]}];//数据类型 变量名=值；可以用逗号隔开来声明多个同类型变量。
public class Demo06 {
public static void main(String[] args) {
// int a,b,c;
// int a=1,b=4,c=8; 程序可读性
String name="wff";
char x='X';
double pi=3.1415;
}
}注意事项：
-
每个变量都有类型，类型可以是基本类型，也可以是引用类型；
-
变量名必须是合法的标识符；
-
变量声明是一条完整的语句，必须以分号结尾。
变量作用域
-
类变量 （需要加关键字static）
-
实例变量 （无关键字）
-
局部变量（在方法里）
public class Demo07 {
//属性：变量
//类变量 static
static double salary=2500;
//实例变量：从属于对象;如果不进行初始化，这个类型的默认值 0 0.0 0000
//布尔值：默认是false
//除了基本类型，其余的默认值都是null
String name;
int age;
//main方法
public static void main(String[] args) {
//局部变量；必须声明和初始化值
int i=66;
System.out.println(i);
//变量类型 变量名字=new Demo07();
//new Demo07(); +Alt+回车+回车变下面
Demo07 demo07 = new Demo07();
System.out.println(demo07.age);
System.out.println(demo07.name);
//类变量 static
System.out.println(salary);
}
//其他方法
public void add(){
}
}
（2）常量（Constant）
-
常量：初始化（initialize）后不能再改变值，不会变动的值！！！
-
常量可以理解为一种特殊的变量，值被设定后，在程序运行过程中不允许被改变。
final 常量名=值；
final double PI=3.14；-
常量名一般是用大写字符。
public class Demo08 {
static final double PI=3.141;
// final static double PI=3.141; 也行，修饰符不存在先后顺序
public static void main(String[] args) {
System.out.println(PI);
}
}在Java中，经常希望某个常量可以在一个类的多个方法中使用，通常将这些常量称为类常量：
public class Demo01 {
public static final double CM_PER_INCH = 2.5;
public static void main(String[] args) {
double paperWidth = 8.5;
double paperheight = 11;
System.out.println("Paper size in centimeters: "
+ paperWidth * CM_PER_INCH + "by" + paperheight * CM_PER_INCH);
}
}变量的命名规范
-
所有变量、方法、类名：要简洁明了，一眼看出意思；
-
类成员变量：首字母小写和驼峰原则：monthSalary；
（驼峰原则即除第一个字母外，后面的单词首字母大写）
-
局部变量：首字母小写和驼峰原则；
-
常量：大写字母和下划线：MIN_VALUE；
-
类名：首字母大写和驼峰原则：GoodWoman；
-
方法名：首字母小写和驼峰原则：run()，runRun();
5、运算符
运算符的优先级
| 优先级 | 运算符 | 结合性 |
|---|---|---|
| 1 | ()、[]、{} | 从左往右 |
| 2 | !、+、-、～、++、-- | 从右往左 |
| 3 | *、/、% | 从左往右 |
| 4 | +、- | 从左往右 |
| 5 | <<、>>、>>> | 从左往右 |
| 6 | <、<=、>、>=、instanceof | 从左往右 |
| 7 | ==、！= | 从左往右 |
| 8 | & | 从左往右 |
| 9 | ^ | 从左往右 |
| 10 | | | 从左往右 |
| 11 | && | 从左往右 |
| 12 | || | 从左往右 |
| 13 | ?: | 从右往左 |
| 14 | =、+=、-=、*=、/=、&=、|=、^=、～=、<<=、>>=、>>>= | 从右往左 |
在默认情况下，虚拟机设计者允许对中间计算结果采用扩展的精度。但是，对于使用strictfp关键字标记的方法必须使用严格的浮点计算来生成可再生的结果。在默认情况下，中间结果允许使用扩展的指数，但不允许使用扩展的尾数。
（1）基本运算符
-
算术运算符：+，-，*，/，%，++，--
-
赋值运算符：=
-
关系运算符：<，>，>=，<=，==，！=，instanceof
-
逻辑运算符：&&，||，！
-
位运算符：&，|，^，～，>>，<<，>>>
-
条件运算符：？：
-
扩展赋值运算符：+=，-=，*=，/=
package operator;
public class Demo01 {
public static void main(String[] args) {
//二元运算符
int a=11;
int b=22;
int c=33;
int d=44;
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println(a/(double)b); //若不加double则为0，小数部分丢弃
}
}package operator;
public class Demo02 {
public static void main(String[] args) {
long a=123445678990087L;
int b=222;
short c=18;
byte d=8;
System.out.println(a+b+c+d); //long
// 如果计算的数中有long类型则计算结果为long类型，如果没有则为int
//如果结果超过该类型的取值范围，则按该类型的最大值取模
//运算结果的数据类型为参与运算的变量中最高优先级的数据类型
System.out.println(b+c+d); //int
System.out.println(c+d); //int
}
}
package operator;
public class Demo03 {
public static void main(String[] args) {
//关系运算符返回的结果： 正确，错误 布尔值
int a=88;
int b=66;
int c=99;
System.out.println(a>b);
System.out.println(a<b);
System.out.println(a==b);
System.out.println(a!=b);
System.out.println(c%a);
}
}
（2）自增自减运算符
package operator;
public class Demo04 {
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);
//幂运算 2^3 2*2*2 使用工具类来操作
double pow=Math.pow(2,3);
System.out.println(pow);
}
}
（3）逻辑运算符、位运算符
逻辑运算符
package operator;
//逻辑运算符
public class Demo05 {
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));//真变假，假变真
//短路运算
//前面为flase，则后面代码不执行
int c=5;
boolean d=(c<4)&&(c++<4);
System.out.println(d);
System.out.println(c);
}
}
位运算符
package operator;
public class Demo06 {
public static void main(String[] args) {
/*
A=0011 1100
B=0000 1101
================================================================
A&B= 0000 1100 只有11得1，其余为0
A|B= 0011 1101 有1就为1，其余为0
A^B= 0011 0001 如果不同则为1，相同则为0
～B= 1111 0010 对B取反
==============================================
2*8=16 2*2*2*2
<< *2
>> /2
//位运算效率极高！！！！！
0000 0000 0
0000 0001 1
0000 0010 2
........
0000 1000 8
.............
*/
System.out.println(2<<3);
}
}（4）三元运算符
扩展赋值运算符
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);
//字符串连接符
System.out.println(a+b);
System.out.println(""+a+b);
//若字符串在前，则结果为字符串拼接；若在后面，则计算
System.out.println(a+b+"");
}
}
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 Doc
（1）包机制
-
为了更好的组织类，Java提供了包机制，用于区别类名的命名空间。
-
包的语法格式为：
package pkg1[.pkg2[.pkg...]];
-
一般利用公司域名倒置作为包名；
-
为了能够使用某一个包的成员，我们需要导入该包
import 包名
（.*为通配符，意为导入这个包下所有的类！）
（2）Java Doc生成文档
-
javadoc命令是用来生成自己API文档的
-
参数信息：
@author作者名、@version版本号、@since指明需要最早使用的jdk版本、
@param参数名、@return返回值情况、@throws异常抛出情况
package com.wmj.base01;
/**
* @author wmj
* @version 1.0
* @since 1.8
*/
public class Doc {
String name;
/**
* @author wmj
* @param name
* @return
* @throws Exception
*/
public String test(String name)throws Exception{
return name;
}
}右键类-->open in explorer-->在导航栏前加cmd-->回车-->javadoc -encoding UTF-8 -charset UTF-8 Doc.java
（学会使用IDEA生产JavaDoc文档！）
参见视频教程：【遇见狂神说的个人空间-哔哩哔哩】 https://b23.tv/rChoen6
870
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
