用名字去声明程序中的各种成员。命名规则：
java中一些标识符是系统声明的，具有专门的意义和用途。不允许作为一般的标识符使用。称为关键字。
关键字都用小写字母表示。java中有50个关键字：
注意：false和true是属于boolean，不能转换为其他数据类型。
常量：是指在程度整个运行过程其值不变的量，在声明变量时，在前面加一个final修饰，就声明了一个常量。常量一旦初始化就不能被改变。
变量：则相反，在运行过程中是可以改变的，但，在使用前一定需要声明。变量有一定的生命周期和作用域。
(1)基本数据类型：（由小到大）
整数类型：byte（8位数）、short（16位数）、int（32位数）、long（64位数）
浮点类型：单精度 float（32位数）、双精度 double（64位数）
字符类型：char（16位数）
布尔类型：boolean（8位数）
(2)引用类型：
字符串、数组、类、接口、Lambda
如果计算的时候超过表示的数据范围就叫溢出。超过最大值：上溢。反之，下溢。
浮点类型的下溢会表示为：0.0；下溢表示为正/负无穷大（+-INFINITY）。
(3)类型之间的转换：
自动转换：将位数小的数据类型向位数多的类型进行转换。
强制转换：则反过来，位数多的向位数小的转换。
自动转换的顺序：byte、short、char-->int-->long-->float-->double
强制转换需要使用（），如：short aa = ‘1‘; byte bb = (byte)aa;
参数传递的问题：
(1)值传递：不会改变变量的值。实际上实参和形参是两个不同的东西，就像形参是实参的一个副本，所以，改变了副本，原本是不会改变的。
public class text { public static void main(String[] args) { int a =10; change(a);// 实参 System.out.println(a); } public static void change(int b){//形参 b=20; } } //打印结果是10，因为改变的只是b，一个副本，原本a没有改变
(2)引用传递：可以改变对象的内容。实际上是实参和形参都指向同一块内存区域，所以，会改变对象的内容。
public class text { public static void main(String[] args) { int [] a={1,2,3}; change(a); System.out.println(a[0]); } public static void change(int[] b ){ b[0]=100; } } //打印100，因为a[0]和方法中b[0]是指向一块内存的
构造函数不能被继承和覆盖，但是可以被重写。this和super是特殊的引用构造函数的关键字。
(1)this：解析引用变量与参数之间的模糊性；作为参数传递给另一个方法。
public class text{ private String name = "huang"; public text(String name){ this.name = name; //解析参数的模糊性 } public text change(){ text tt = new text(this); //作为参数传递给下一个 tt.name = "can"; return tt; } }
(2)super：获取父类中变量数据和调用父类中方法；直接调用父类的构造方法。
class text1{ //父类 String name； public text1(){} public void ways(){ System.out.println("我是父类"); } } class text2 extends text1{ public text2(){ super();//直接调用父类的构造函数 //super.name; 调用父类的属性 //super.ways(); 调用父类方法 } }
java对基本数据类型不作为对象处理。需要使用包装类才可以当作对象处理。
boolean->Boolean、byte->Byte、char->Character、short->Short、int->Integer、long->Long、float->Float、double->Double、void->Void、
运算：对各种类型的数据进行加工的过程。运算符：表示不用运算的符号。操作数：参与运算的数据。
表达式：由操作数和运算符组成。表达式运算之后的值的类型称为表达式的类型。
java中的算术运算符分为一元、二元运算符。
1、一元运算符：
+ (一元加)，- (一元减)，++ (增量)，-- (减量)；
注意：++i和i++的区别。
(1)单独使用：都是表示 i = i + 1
(2)结合其他表达式使用：++i是在使用前，先加上1，再去运算。i++是先运算后再加1
2、二元运算符：
+ (加)，- (减)，* (乘)，/ (除)，% (取模/求余)
注意：运算后表达式的类型
(1)如果操作数全是整型，其中只要有一个是long，则，表达式类型是long。其他的，结果都是int类型。
(2)如果操作数是浮点类型，只要有一个double，则结果就是double。只要是两个都是float，或者一个float，另一个是整型，结果才是float类型。
3、三元运算符：？：
操作的是判断和赋值的一个过程。格式：条件表达式 ？表达式1：表达式2。
4、关系运算符：
> ，<，>=，<=，== (等于)，!= (不等于)
注意：== 和 equals()的区别
(1)== ：是指两个变量或实例是不是指向同一个内存空间。
(2)equals():是指两个变量或实例指向的内存空间的值是否一致。
5、逻辑运算符：
&& (逻辑与)，|| (逻辑或)，！(逻辑非)
&&和||都是“短路”方式进行运算的，&&：只要左边的逻辑为false，就不会执行右边的语句，||：只要左边为true，也不会执行右边的语句
6、位运算符：
~ (按位取反)，& (按位与)，| (按位或)，^ (按位异或)，>>(按位右移)，<< (按位左移)，>>> (添零右移)
位运算符是相对于二进制数来进行位的计算的。
(1) ^ (按位异或)：两个操作数之间，相应的位相同，结果为0，反之为1。
01010110 ^ 00101110 --> 01111010
(2) >> (按位右移)：将一个数的二进制右移若干位。（右移1位相当于除2取商）
a = 11001011 则：a>>2 = 00110010
(3) << (按位左移)：将一个数的二进制左移若干位。（左移1位相当于乘2）
(4) >>> (添零右移)：和按位右移相同，但是，最高位是补零。
7、赋值运算符：
就是在其他的运算符后面添加一个=。如：+=、-=。
8、运算符的优先级：（由高到低）
1、最简单的是: if 、if...else、if...else if()...else、
2、多分支语句：switch...case....default....
注意：使用switch...case时：switch()括号里面的类型只能是byte、short、int、char类型。并且break的使用要慎重。如果case语句里面没有break;则执行完匹配的case语句后，后面的case里面的语句也一样会执行。
3、循环语句：
(1) while(条件) (当型循环)：先计算括号的条件。满足后才执行循环体中的代码。
(2) do...while(条件) (直到型循环)：先执行一次，再判断条件，如果满足，再执行循环体代码。
(3) for(初始化、条件、迭代){ }：
4、break的应用
(1) 可以作为退出循环的语句。直接是使用break；
(2) 可以作为“标签化中断”。用法是 break 标记;
outer : for(int i = 0; i < 10; i++){ inner ：for(int j = 0; j < 10; j++){ if(i = 9){ break outer; //跳出最外的循环 } } }
5、continue的应用
是跳过循环体中下面未执行的语句，继续下一轮的循环。
for(int i = 0; i < 10; i++){ if(i == 5) continue; System.out.println(i); //不会打印5，因为continue跳出尚未执行的语句，执行下一轮 }
6、递归的应用
递归，通俗来说就是自己调用自己。把问题逐渐简单化。
递归的程序非常简洁，但是需要占用大量的系统堆栈，内存消耗多。
//模拟一个求阶乘的例子 long ways(int n){ if(n== 1) return 1; else return n * ways(n-1); }
1、Object类
是所有类的根类。有6个方法可以被系统中任何类继承。
2、Class类
是一个自引用的数据类型。可以表示所有的java数据类型。最大的用途就是在程序执行期间帮助加载新的类。因为java中支持动态加载，所有的类仅当第一次引用时才需要加载到系统中。
主要的特性：
java中，没有表示字符串的基本数据类型，只是双字节的Unicode字符序列。对字符串的处理用String、StringBuffer、StringBuilder来完成。该三个类都是final类，不能被其他类继承。String的字符串长度是不可变的。StringBuffer长度可变，支持多线程，速度稍慢。StringBuilder长度可变，不支持多线程，速度快。类中提供了很多方法，下面介绍几种常用的。
String中的：concat()拼接、replace()替换、substring()获取子串、toLowerCase()变小写等。具体看api文档
覆盖（重写）：子类必须和其父类的某个方法有相同的名称、返回类型和参数。如果一个方法被定义了final，是强制禁止覆盖的。如果被定义了abstract，是强制进行覆盖的。
重载：同一个类中有多个相同的方法名称，但是有着不同的参数类型的表现方式，体现为：参数的个数、参数的顺序、参数的类型。重载和访问的修饰符、返回值类型无关。
如果父类中的方法使用了private修饰，在子类中都不能进行覆盖和重载。
两者区别：
5、抽象类
不能被实例化的类。并且必须被继承实现，其方法也必须要被重写。
抽象类中可以不包含抽象方法。但是抽象方法所在的类，一定是抽象类。
static、private、final方法不能被抽象，因为不能被子类覆盖。并final不能包含抽象方法。
abstract class text{ //定义抽象类 abstract void add(); //抽象方法是没有方法体的 }
6、接口
接口是与类关联紧密的一种引用类型。不能通过new进行实例化，必须要使用新的类来implements来实现接口。接口不仅是抽象类，而且包括任何实现，所以与存储空间无关。使用多个接口进行合并，就容易实现了多重继承的技术。
接口中的方法是没有方法体的。可以包含数据成员。但是一定是使用static和final声明的常量。
interface text{ final String name= "huang";//声明常量 public void add();//接口中的方法 }
7、内部类
也叫嵌套类。允许一个类声明放入另一个类声明中。
特点：
声明的两种方法：
(1) 类中声明内部类，可以在内部多次使用
(2) 用new声明匿名内部类。创建一个对象
//(1)类中声明 class A{//外部类 class B{//内部类 void show() { System.out.println("我是内部类"); } } } //(2)new声明 ActionListener al = new ActionListener(){ //匿名内部类 public void actionPerformed(ActionEvent event){ } }
是存储一系列同类型的数据元素的一种数据结构。通过数组名和整型下标可访问数组中的每一个元素。如：a[i]
数组创建的两种方法：
静态初始化、动态初始化
//(1)静态初始化 int[] a = {1,2,3}; int[] b = new int[]{1,2,3}; //(2)动态初始化 int[] c = new int[3]; c[0]= 1; c[1]= 2; c[2]=3;
二维数组的创建和一维的是一差不多的，int[][] a = new int[2][3];这样声明的是有两行三列的数组。
ArrayList：能动态自动调整数组大小。不必限定数组的大小。
创建方式：ArrayList aa = new ArrayList();
一些基本方法：add()添加元素、clear()删除元素、clone()克隆元素、get(i)获取元素。
原文：https://www.cnblogs.com/huangcan1688/p/12187991.html
