一年前学习Java的总结
目录
注释
注释就是方便自己或者别人阅读代码，绝大多数的程序语言都有注释这个功能，大部分的注释命令都是相同的或者想通的，
下面给出Java的注释结构
三类注释
//单行注释
/*多行注释*/
/**文本注释*/
注意：/*多行或者文本注释*/不能嵌套。后面的*/或匹配前面的。
文本注释可以用来自动生成程序文档。
数据类型
Java是一种强类型语言，也就是说每一个变量声明都需要一种数据类型，作为一款可移植性，跨平台可用的语言，当然不像C、C++这种换平台，64位OS->32位OS，数据类型空间就发生改变，JVM的好处呗。
- 数据类型划分两类
基本数据类型：
数值型
整型：byte short int long 默认值：0；
浮点型：float double 默认值0.0
字符型：chat ’\u0000' ‘
布尔型：Boolean false
引用数据类型：
数组 类 接口 默认值：根据存放内容，初始化不同值，对象（null）,基本数据类型（默认值）。
- 整型
声明一个数据类型
一个数据溢出(最小值？）的问题 int maxValue = Integer.MAX_VALUE +1
一个变量命名要求 首字母小写 下个单词大写）
操作前预估数据大小 怎么解决溢出问题：换个数据类 long解决interest的数据溢出问题，（有一个大数值的概念）
在使用方法处理时，要注意 所有的程序执行顺序都是 由等号的右边到左边，计算还会溢出，
溢出的问题
一 将int 的数据变量赋值给long
long result = maxValue;
long result = maxValue +1; //出错 这里涉及到一个自动转换的问题， 等号右边到左边；二 直接将某一int型变量变为long型
long result = （long）maxValue +1;//强制转换数据类型也可以以小变大！！（强制完成- 肯定会丢内容,少用 少用）
任何整数其默认数据类型，所以 long i= 2147483648; 编译是错误的 int型储存不了那么的数字范围 所以在int型 强制转换前就出错了。
类比。
long i = 2147483648L (L/l)
重要说明
关于数据类型的默认值， 这个默认值在方法（主方法）中声明无效 int num; 直接输出 System.out.print(num) 出错
class Untitled {
public static void main(String[] args) {
int i ;
System.out.println(i);
}
}
Untitled.java:4: error: variable i might not have been initialized
System.out.println(i);
^
1 error
byte数据保存范围问题 十进制为（ -128--127. ），1字节
byte i = 10 ；// 输出也是 10 ，为什么没错， 10 int型 可以强制转换成 byte 可以保存下。
byte i = 128； //从 int转换到 byte 可能有损失。
byte i = （byte）128 //溢出 ！
byte i = (int j = 10); //出错！！运行：等号右边到左边，小的自动转大的
byte i = (byte) (int j = 10);- 浮点型
描述小数的数据，默认是double。
如果要用float，要强制转换，在数字后加一个F/f。、
float f = 1.1 ； //错误，从double转换float可能有损失。
float f = 1.1F；
float f = （float）1.1；（Java 的一个but ， 输出的数有一推零。）
精度问题（int型 除 int型 等 int型 ， 10/4 =2 ，错误。 ）
- 字符型
会使用字符型的概念，但是很少使用char， 单引号 chat c ='A';
麻烦的地方在 int型的转换等比较难， Unicode编码，十六进制编码。包含ASCII。
常用范围
大写字母A-Z；65—90 小写字母a-z；97 -122（相差32个）
chat c ='A';
int num = c + 32; //等于int 型 ，大的范围类型加小范围类型，等于大的数据类型
字符数字（‘0’-‘9’），48-57.
另外一个神奇的用法，
变量命 类名 直接用中文都可以。命名标识符
char只可以描述单一字符， 多个字符用String，String不是基本数据类型是一种引用数据类型
‘’+‘’ 两个字符串相加， int+double+String 结果（String)为字符串相加连接，不能用减。解决方法：（int+double)+String
还存在一种转义字符！ 可以对字符串进行一些操作。
这里也涉及到一个Unicode和char的问题，要从编码机制开始说，就不谈了。
- 布尔型
一般指逻辑结果，其他语言没有布尔型，其他语言用0 1表示 .
变量
刚说的，Java是一种强类型语言，也就是说每一个变量声明都需要一种数据类型
命名规范，大小写敏感，不能用Java关键字。（可以看阿里巴巴的开发手册）
public calss Constants{
int i ;
int i = 1;//变量声明
public static void main(String [] arg){
int i ;//局部变量声明，上面说了，这个无效
int i = 1;//局部变量声明
final double i = 2.3;//加了final关键字就是常量了，不能改变值
}
public static final double i = 2.3;//类常量，别的类可直接访问。
}运算符
程序的计算 别写特别的复杂运算。可使用Math类下的方法，关于这些算法，其实都是用C写的，有兴趣可以看算法网站
- 基本四则运算
自增运算：++变量（先加再运算）。 变量++（先运算再相加）。
自减运算。
- 三目运算
赋值运算，根据条件运算。
int result = x > y ? x : y;
不熟悉，也可以写if判断。代码行数太多了。
- 关系运算符
>,<,<=,==,!=.返回结果都是布尔型。字符和数字判断 ‘a’ == 97 ;
- 逻辑运算
与， 或 ，非（！） 。 返回布尔型
& ， && (单& 全部都都返回了，不管后面是怎么样， 双&&，（短路与），判断一个就行了）
| ， | | （单 | 全部都返回了， 双||判断前面就ok了。）
- 位运算（了解）
按照二进制 十六进制 等进行 数据移位处理。
位运算实现的关键问题再与要进行十进制与二进制的转换，转换原则是 数据除 2 取余，一直除到 0 为止，说有的余数按照倒序排列。
- 运算符优先级，运算可以直接加括号。（）
- 常见运算符使用例子
int x ;
x += 4; x = x + 4;
x +=3.5; x = (int) x + 3.5;
x++; x = x + 1;//先赋值再运算
++x; x = x + 1;//先运算再赋值
if(x != 0 && x++>y ) //前面要是false了，后面是不会运行的。
enum Size{s,m,l,x};//枚举
Size s = Size.s;字符串
Java是没有字符串类型的，它只是Unicode字符序列，其实就是一个字符数组（char [ ]），String是一个Java一个预定义类，也称为不可变字符串。
String e = ""; //一个空字符串
if(e != null&& e.length != 0);//判断字符串，因为String还有一个特殊的值null;
- 子串
String e = "hello";
String sube = e.substring(0,2);//hel
//源码
public String substring(int beginIndex) {
if (beginIndex < 0) {
throw new StringIndexOutOfBoundsException(beginIndex);
}
int subLen = value.length - beginIndex;
if (subLen < 0) {
throw new StringIndexOutOfBoundsException(subLen);
}
return (beginIndex == 0) ? this : new String(value, beginIndex, subLen);
}- 拼接
java语言允许使用加号连接两个字符串，需要注意的是这是生成一个新对象，jvm的垃圾回收会解决旧对象的回收问题。
- 检查字符串是否相等
==和.equal
在引用数据类型中==比较的是：在内存中的地址是否相等。
在基本数据类型中==比较的是：值是否相等。
.equal的问题，由于String对象是利用字符常量形成的数组，并且内部有一个字符串共享的存储池的概念；
String a = "hello";//在字符串共享池中存入。
String b = "hello";//先在共享池中查找到相同对象，引用相同内存地址，共享池就是一个对象数组
a==b;//是相等的，内存地址相等；so,一般比较字符串大小使用.equal。
if(e.equal(hello)）;
if(e.compareTo("hello"));//类似上面的
//.equal源码java.lang.String类
/** The value is used for character storage. */
private final char value[];
public boolean equals(Object anObject) {
if (this == anObject) {
return true;
}
if (anObject instanceof String) {
String anotherString = (String)anObject;
int n = value.length;
if (n == anotherString.value.length) {
char v1[] = value;
char v2[] = anotherString.value;
int i = 0;
while (n-- != 0) {
if (v1[i] != v2[i])
return false;
i++;
}
return true;
}
}
return false;
}
- 字符串原理
字符串由char值序列组成的，char类型是一个采用UTF-16编码表示unicode码点的代码单元。（有一些字符需要两个代码单元）
String e = "hello";
String num = e.length();//获取代码单元(在内存中的大小) 5
String num = e.codePointCount(0,e.length());//获取码点(实际看到的数量) 5
/** The value is used for character storage. */
private final char value[];- 一些字符串注意点
我们尽量减少使用char类型，因为这个太底层了，太多技术细节了，
String类是一个非线程安全的，并且一部小心就生成了很多String对象,浪费空间和时间，虽然jvm有自动垃圾回收，但是也是系统的一个负担。
so,使用StringBuilder类，或者StringBuffer类（线程安全）。
控制流程
- 顺序结构
分支结构，逻辑判断，满足某些条件才执行
if 分支结构
if（布尔表达式）{
满足条件时执行代码；
}else if（ 布尔表达式）{
条件满足时的执行代码；
}。。。【else】{
所有条件都不满足时执行的代码；
}
switch分支结构
switch（数字|枚举|字符|字符串）{
case 内容1 ：{
瞒住的条件执行
【break】~停止的
}
default{
都不满足执行
}
}- 循环结构
while循环
while（布尔表达式）（
循环语句；
修改循环结束田间判断；
}
另 do -- while(始终执行一次） 基本不使用
for循环
FOR（循环初始条件；循环结束判断；修改循环条件{
循环代码
}对于不知道循环次数的用while， 知道次数的使用for循环。
循环控制
continue： 跳过当前的循环，循环体后面的不执行。回到循环语句开头
brake：结束整个循环体
循环嵌套，用的不多。
数组
数组是一种引用数据类型，用来存储同一类值的集合，通过一个整型下标可以访问数组中的每一个值。
- 数组初始化
int a[];
int [] a ;//声明整型数组a,只是声明了变量。
int [] a = new int[100]//创建数组,下标为0-99。
int [] b = {1,2,3};//简写
b = new int[]{3,5,4};//匿名数组
- 数组拷贝
数组拷贝，只是两个变量引用同一个数组，也就是同一个堆地址。同一块堆被不同块栈指向，堆真实数据 ， 栈保存堆的地址。
int [] a = {1,2,3};
int [] b = Arrays.copyOf(a,a.length);
//源码
public static int[] copyOf(int[] original, int newLength) {
int[] copy = new int[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}- 数组排序与查找
Java语言是完全面向对象的，相比于“结构化”的语言，注重方向是一样的，Java，更加注重数据结构，而不是算法。so，这里就谈算法的问题啦，直接使用api。
int [] a = {1,3,2,5};
int [] b = Arrays.sort(a);//优化了的快速排序算法
int c = Arrays.binarySearch(a ,0 ,3 ,2);//二分搜索查找算法- 多维数组
Java实际上是没有“多维数组”的概念的，但是可以用“数组的数组”代替。
int [][] a ;//声明
int [][] a = new [1][2];//初始化化
int [][] a = {
{1,2,3},
{2,3,4}
};//简写
//不规则数组
int [][] b = {
{1,2,3},
{1,2,3,4,5}
};
//可以用foreach输出数组
foreach(int [] row : b){
foreach(int value : row){
System.out.println(value);
}
System.out.println("---");
}
总结
这些是很基础的东西，绝大多是编程语言都支持，并且相差不会很大，上面说的是远远不够的，这只是自己一年前的总结（原因在这里），这些基础其实敲多了，就自然的熟悉了。