原文章地址：http://blog.csdn.net/luoweifu/article/details/6776240
 
Java中的50个关键字
    关键字也称为保留字，是指java语言中规定了特定含义的标示符。对于保留字，用户只能按照系统规定的方式使用，不能自行定义。Java中有50个常用关键字：
 
与数据类型相关（10）
 
关键字
类型
占字节数
备注
boolean
布尔数据类型
1
有true和false两个值
int
整型数据类型
4
 
long
长整型数据类型
8
 
short
短整型数据类型
2
 
byte
字节数据类型
1
大小范围为-27—27-1
float
浮点型（实数型）
4
 
double
双精度型数据类型
8
 
char
字符型数据类型
2(Unicode码)
 
class
表示一个类
不确定
可用于定义一个类。
interface
表示一个接口
不确定
可用于定义一个接口
与流程控制相关（13）
if： 表示条件判断，一般用法if（关系表达式），后跟else或{……}
else： 条件转折，如if （关系表达式）{语句块1}else{语句块2}，如果关系表达式的值为true，则执行语句块1，否则执行语句块2.
do……while……：do和while一般一起使用，用于表示循环语句。do{……}while（关系表达式）……；当关系表达式的值为true是继续循环。
for：用于表示循环，for循环是最常使用的循环，格式for（表达式a; 表达式b; 表达式c）括号里面的书通常用于控制循环的次数，一般会用一个int类型的变量类计数，如（int
 i=0; i<10; i++）表达式a用于流程控制的开始值，表达式b表示循环终止条件，表达式c用于计数。
switch（条件a）case……：switch和case合起来用于表示条件分支流程。如：

while(int c) {

case 1: {语句块1} 

case 2: {语句块2}

……?????? ……

case n: {语句块n}

default：exit(0);

}
如果c为1，则执行语句块1；如果c为2，则执行语句块2；以此类推，如果c为n，则执行语句块n。default表示除case以外出现的情况。
default：在switch……case……分支语句可知，default是在所有case条件下都不成立时使用。用于包表示s“rc”文件夹下的当前包；如果用于类，表示只可被本文件内的其它类访问。
break：用于结束本层循环，或跳出某层循环。
continue：用于跳出本次循环，而break跳出本层循环。Break和continue可以实现类似于C\C++中goto语句的用法：

label0:

{

　for (int k = 0; k < 10; k++) {

　.......... 

　label1:

　for (int j = 0; j < 10; j++) {

　　................

　　break label0;　　//跳转至label0

　}

　...........

　label2:

　for (int kk = 0; kk < 10; kk++) {

　　..............

　　break label0;　　//跳至label2
　}

}
return:返回一个值，通常用于函数中，返回一个具有特定类型的值。如:
public int fuction()
{
　　int a; 
　　……
　　return a;//返回int型的值
}

try……catch……finally……：用于异常处理，使用形式如：
try{

　……

}catch(类型b){

　……

}finally{

　……

}
try{……}中放置可能会发生异常的的语句块，catch(){……}用于抓住异常，{}定义当出现异常时的处理方法。finally{……}表示不管异常是否发生，都得进行finally{}中的处理。
与修饰符相关（12）
不同访问修饰符的访问权限
范围
本类
同软件包
不同包中子类
不同包且无继承
作用(含义)

public
可以
可以
可以
可以
公有的

protect
可以
可以
可以
 
受保护的

default(无权限修饰符)
可以
可以
 
 
当前的

private
可以
 
 
 
私有的
如：
一个".java"后缀名的文件里面只能一个publi型的cass类。如c13.swing包下有HelloWorld.java 文件，该文件下有如下代码：
package c13.swing;
public class HelloWorld {
	public void show() {
		System.out.println("HelloWorld!");
	}	
}
在default包下有如下代码：
import c13.swing.*;//引入所需要的包里的所有类
public class Test {
	public static void main(String args[]) {
		HelloWorld h = new HelloWorld();
		h.show();
	}
}
此时运行正常，结果：HelloWorld!
如果把public class HelloWorld改成privateclass HelloWorld则会运行错误，因为private是私有的不能被其他包内的对象所引用。
final：(类似于C++中的const)，用法如下：

a，final的变量的值不能被改变；1），final的成员变量； 2）final的局部变量；

b，final的方法不能被重写；

c，final的类不能被继承。
void：空类型，用于函数前表示空返回值。
static：可用于定义静态成员变量或方法
strictfp：意思是FP-strict，也就是说精确浮点的意思。在Java虚拟机进行浮点运算时，如果没有指定strictfp关键字时，Java的编译器以及运行环境在对浮点运算的表达式是采取一种近似于我行我素的行为来完成这些操作，以致于得到的结果往往无法令你满意。而一旦使用了strictfp来声明一个类、接口或者方法时，那么所声明的范围内Java的编译器以及运行环境会完全依照浮点规范IEEE-754来执行。因此如果你想让你的浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，那就请用关键字strictfp。  

你可以将一个类、接口以及方法声明为strictfp，但是不允许对接口中的方法以及构造函数声明strictfp关键字，例如下面的代码： 
1. 合法的使用关键字strictfp 

strictfp interface A {}
public strictfp class FpDemo1 { 

strictfp void f() {} 

} 

2. 错误的使用方法 

interface A { 

strictfp void f(); 

}
public class FpDemo2 { 

strictfp FpDemo2() {} 

}
一旦使用了关键字strictfp来声明某个类、接口或者方法时，那么在这个关键字所声明的范围内所有浮点运算都是精确的，符合IEEE-754规范的。例如一个类被声明为strictfp，那么该类中所有的方法都是strictfp的。
abstract：抽象的意思，可以用定义抽象类，抽象函数。抽象类的用法规则如下：

a，用abstract关键字来修饰一个类时，这个类叫做抽象类；用abstract来修饰一个方法时，这个方法叫做抽象方法；

b，含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写；

c，抽象类不能被实例化；

d，抽象方法只需声明，而不需实现。
transient: Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。

 使用对象：字段

介绍：字段不是对象持久的一部分，不应该字段和对象一起串起。
synchronized：锁定当前对象，在执行当前这个对象时不应许其他线程打断插入。使用的方式有：
这是我在暑假学习做的笔记
（1），class Timer {

private static int num = 0;

public synchronized void add(String name) { //执行这个方法的过程中锁定当前对象。

num ++;

try {

Thread.sleep(1);

} catch( InterruptedException e) {

return;

}

System.out.println(name + ",你是第" + num +"使用Timer的线程。");

}

}

（2），class Timer {

private static int num = 0;

public void add(String name) { 

synchronized(this) { //锁定大括号这个区域的代码段

num ++;

try {

Thread.sleep(1);

} catch( InterruptedException e) {

return;

}

System.out.println(name + ",你是第" + num +"使用Timer的线程。");

}

}

}
volatile：volatile变量一个时间只有一个线程可以访问。 保证线程安全。 

可以被写入 volatile 变量的这些有效值独立于任何程序的状态，包括变量的当前状态。 

所以，Volatile 变量是一种非常简单但同时又非常脆弱的同步机制，它在某些情况下将提供优于锁的性能和伸缩性。
native：是用作java 和其他语言（如c++）进行协作时用的也就是native 后的函数的实现不是用java写的， native的意思就是通知操作系统，这个函数你必须给我实现，因为我要使用。所以native关键字的函数都是操作系统实现的， 
 java只能调用。
与动作相关（10）
package：打包，把java程序写在一个包中。
import：引入报名，用法： 

a，写全包名：jsxt.java140.Cat c = new com.bjsxt.java140.Cat

a，引入一个包中的具体某个对象：xt.java140.Cat;

b，引入一个包中的所有象：import com.bjsxt.java140.Cat.*;
throw：抛出用户自己定义的异常
throws：抛出系统异常
extends：继承（类继承类，或接口继承接口）
implements：实现，通过类来实现接口
this：是指向该对象自身的标示符
super：调用基类的构造函数
instanceof：判断某个对象是否为自己所要的对象
new：用于新建一个对象，即类的实例化
其他（5）
true：表示boolean类型的真值
false：表示boolean类型的假值，即不成立的情况
null：表示空值，如果是对象，则表示此对象为空，如果是数据类型，在表示相应数据类型的默认值，如int的默认值为0。
goto：C\C++中实现无条件转向语句，为了结构化程序设计java中现在一般不用。
const：和const一样，在Java中,const是作为保留字以备扩充。可以用final替换const，一般C++中用const，java中用final。

TF-IDF
TF-IDF（Term Frequencey-Inverse Document Frequency）指词频-逆文档频率，它属于数值统计的范畴。使用TF-IDF，我们能够学习一个词对于数据集中的一个文档的重要性。
TF-IDF的概念
TF-IDF有两部分，词频和逆文档频率。首先介绍词频，这个词很直观，词频表示每个词在文档或数据集中出现的频率。等式如下：

TF(t)=词t在一篇文档中出现的次数/这篇文档的总词数

第二部分——逆文档频率实际上告诉了我们一个单词对文档的重要性。这是因为当计算TF的时候，我们对每个词赋予了同等的重要性，它出现得越多，它的TF就越高，如果它出现了100次，也许相比其他出现更少的词，它并不携带那么多信息，因此我们需要赋予它们权重，决定每个词的重要性。使用下面的等式得到IDF：

IDF(t)=(log10文档的篇数/包含词t文档的篇数)

那么，计算TF-IDF的方法如下：

TF * IDF=(词t在一篇文档中出现的次数/这篇文档的总词数)* log10(文档的篇数/包含词t文档的篇数)
应用
TF-IDF可以应用于如下场景：

通常可以使用TF-IDF进行文本数据分析，得到最准确的关键词信息。
如果你正开发一个文本摘要应用，并正在进行统计，TF-IDF是生成摘要最重要的特征。
TF-IDF权重的变动常用于搜索引擎，以求出文档的得分以及同用户检索的相关性。
文本分类应用将TF-IDF和BOW一起使用。

TextRank
TextRank 算法是一种用于文本的基于图的排序算法。其基本思想来源于谷歌的 PageRank算法, 通过把文本分割成若干组成单元(单词、句子)并建立图模型, 利用投票机制对文本中的重要成分进行排序, 仅利用单篇文档本身的信息即可实现关键词提取、文摘。和 LDA、HMM 等模型不同, TextRank不需要事先对多篇文档进行学习训练, 因其简洁有效而得到广泛应用。
基于TextRank的关键词提取
关键词抽取的任务就是从一段给定的文本中自动抽取出若干有意义的词语或词组。TextRank算法是利用局部词汇之间关系（共现窗口）对后续关键词进行排序，直接从文本本身抽取。其主要步骤如下：

把给定的文本T按照完整句子进行分割，即
对于每个句子，进行分词和词性标注处理，并过滤掉停用词，只保留指定词性的单词，如名词、动词、形容词，即，其中是保留后的候选关键词。
构建候选关键词图G = (V,E)，其中V为节点集，由（2）生成的候选关键词组成，然后采用共现关系（co-occurrence）构造任两点之间的边，两个节点之间存在边仅当它们对应的词汇在长度为K的窗口中共现，K表示窗口大小，即最多共现K个单词。
根据上面公式，迭代传播各节点的权重，直至收敛。
对节点权重进行倒序排序，从而得到最重要的T个单词，作为候选关键词。

python实现：
# 导入库
import jieba.analyse  # 导入关键字提取库
import pandas as pd  # 导入pandas
import newspaper
# 读取文本数据
# 获取文章 银保监会出台新政为例
article = newspaper.Article('https://finance.sina.com.cn/money/bank/bank_hydt/2019-02-25/doc-ihsxncvf7656807.shtml', language='zh')
# 下载文章
article.download()
# 解析文章
article.parse()
# 对文章进行nlp处理
article.nlp()
# nlp处理后的文章拼接
string_data = "".join(article.keywords)
# 关键字提取
def get_key_words(string_data, how=''):
    # topK：提取的关键字数量，不指定则提取全部；
    # withWeight：设置为True指定输出词对应的IF-IDF权重
    if how == 'textrank':
        # 使用TextRank 算法
        tags_pairs = jieba.analyse.textrank(string_data,  topK=5,  withWeight=True)  # 提取关键字标签
    else:
        # 使用TF-IDF 算法
        tags_pairs = jieba.analyse.extract_tags(string_data,  topK=5,  withWeight=True)  # 提取关键字标签
    tags_list = []  # 空列表用来存储拆分后的三个值
    for i in tags_pairs:  # 打印标签、分组和TF-IDF权重
        tags_list.append((i[0], i[1]))  # 拆分三个字段值
    tags_pd = pd.DataFrame(tags_list, columns=['word', 'weight'])  # 创建数据框
    return tags_pd

keywords = get_key_words(string_data)
print("#####################TF-IDF####################")
print(keywords)

keywords_tr = get_key_words(string_data, how='textrank')
print("#####################textrank####################")
print(keywords_tr)

结果如下：
#####################TF-IDF####################
   word    weight
0  民营企业  0.327466
1    贷款  0.112652
2    融资  0.089557
3  商业银行  0.084860
4    服务  0.072322
#####################textrank####################
   word    weight
0  民营企业  1.000000
1     要  0.553043
2    贷款  0.493173
3    融资  0.379846
4    服务  0.371273

1 JAVA语法基础
1.1 标识符
标识符可以简单的理解成一个名字。

在Java中，我们需要标识代码的很多元素，包括类名、方法、字段、变量、包名等等。我们选择的那个名称就称为标识符，一个正确的标识符需要遵循以下规则：
1. 标识符可以由字母、数字、下划线（_）、美元符（$）组成，但不能包含 @、%、空格等其它特殊字符
2. 不能以数字开头。如：123name 就是不合法
3. 标识符严格区分大小写。如: tmooc 和 tMooc 是两个不同的标识符
4. 标识符的命名最好能反映出其作用，做到见名知意。
5. 标识符不能是Java的关键字
1.2 关键字
在Java中,有一些单词被赋予了特定的意义,一共有50个关键字。

这50个单词都是全小写,其中有两个保留字:const和goto。

注意,关键字不能被用作标识符！



需要注意的是，除了上述的50个关键字以外，true,false,null也不可以被用作标识符~
1.3 注释
几乎所有编程语言都允许程序员在代码中输入注释,因为编译器会忽略注释,所以注释并不会影响程序的运行结果。

注释的真正作用是： 它可以向任何阅读代码的人描述或者解释程序的实现思路,如何使用以及其它任何相关信息， 提高代码的可读性,方便后期的维护与复用。Java的注释有3种:
1. 单行注释: 注释单行内容.
格式: 每行都以”//”开头.

快捷方式: Ctrl+/ 添加注释,同样的快捷键,再按一次取消注释
2. 多行注释：注释多行内容,虽然叫多行注释,也可注释单行内容.
格式: 以” /* ”开头， 以”  * / ”结束.

快捷方式: Ctrl+shift+/ 添加注释, Ctrl+shift+\ 取消注释, 也可以输入”/*”之后按回车添加注释
3. 文档注释: 一般用来注释类和方法,通过注释内容来记录类或者方法的信息.
格式: 以” /** ”开头。 以” */ ”结尾.

快捷方式: 输入“/**” 之后按回车添加注释
1.4 变量
在JAVA中，我们需要记录一些数据,但这些数据的值是不固定的，总在变，我们可以把这些数据理解为变量。

我们通过三个元素来描述变量：变量类型 变量名以及变量值。

int age  =  18;   //声明int类型的变量并赋值

String tel ;  //声明String类型的变量
注意：

变量名必须是一个有效的标识符
变量名不可以使用java关键字
变量名不能重复

1.5 常量
在程序运行过程中,值一直不会改变的量成为常量。(后续会进一步学习,略…)
2 数据类型
2.1 基本类型介绍(八种)
变量就是申请内存来存储值。也就是说，当创建变量的时候，需要在内存中申请空间。

java是一个强类型的语言,会把日常见到的数据,分成好多类型.

内存管理系统根据变量类型来分配存储空间，分配的空间只能用来储存该类型数据。

常用的转换关系:

位 bit，来自英文bit，音译为“比特”，表示二进制位。

1 Byte = 8 Bits (1字节 = 8位)

1 KB = 1024 Bytes   1 MB = 1024 KB   1 GB = 1024 MB
2.2 练习: 输入个人信息
创建包: cn.tedu.basic

创建类: TestInfo.java

需求: 在控制台打印: java架构师今年20岁，月薪100000.99，感慨java是世界上最好的语言
package cn.tedu.basic;
/**
 * 	本类用于测试在控制台打印个人信息
 * 	需求: 在控制台打印: 
 *  java架构师XXX今年X岁，月薪XXX，感慨java是世界上最好的语言
 *  @author XYCheng
 */
public class TestInfo {
	//Alt+/ 提示补全代码  Ctrl+s保存代码  Ctrl+F11执行代码
	public static void main(String[] args) {
		/**1.在我们的程序当中{} [] () "" 都是成对出现的,而且都是英文符号*/
		/**2. 一串数据,在java里是字符串类型—String  
		 * 字符串类型的数据,要被一对双引号 引起来*/
		System.out.println("欢迎来到Java世界,可爱的程序猿们");
		
		/**3.定义变量的规则:数据类型 数据名 数据值 */
		String name="陈子枢";
		int age = 18;
		double salary = 100000.99;
		
		/**4.把静态数据与动态数据分开,通过+实现动态数据的动态拼接*/
		System.out.println("我叫"+name);
		/**5.如果是在中间拼接用""+变量+""的格式*/
		System.out.println("java架构师"+name+",今年"+age+"岁,月薪"+salary+",感慨java是世界上最好的语言");
	}
}

2.3 练习：查看基本类型的最大值与最小值
创建包: cn.tedu.basic

创建类: TestTypeScope.java
package cn.tedu.basic;
/**
 * 本类用于查看基本类型的最大值与最小值
 * Ctrl+Alt+向下键 快速向下复制一行
 */
public class TestTypeScope {
	//必须要写入口函数,否则代码无法执行,因为没有入口
	public static void main(String[] args) {//入口函数
		//进行整形类型的测试 byte1 short2 int4 long8
		//1.定义变量,用变量分别保存最大值与最小值
		//定义变量 数据类型 变量名 变量值 Ctrl+Alt+向下键 快速向下复制一行 换位置:Alt+方向键
		/**JAVA提供了对应的基本类型的工具箱*/
		byte byteMax = Byte.MAX_VALUE;
		byte byteMin = Byte.MIN_VALUE;
		System.out.println("byte类型的最大值是:"+byteMax);//127
		System.out.println("byte类型的最小值是:"+byteMin);//-128
	
		short shortMax = Short.MAX_VALUE;
		short shortMin = Short.MIN_VALUE;
		System.out.println("short类型的最大值是:"+shortMax);//32767
		System.out.println("short类型的最小值是:"+shortMin);//-32768
		
		int intMax = Integer.MAX_VALUE;
		int intMin = Integer.MIN_VALUE;
		System.out.println("int类型的最大值是:"+intMax);//2147483647
		System.out.println("int类型的最小值是:"+intMin);//-2147483648
		
		long longMax = Long.MAX_VALUE;
		long longMin = Long.MIN_VALUE;
		System.out.println("long类型的最大值是:"+longMax);//9223372036854775807
		System.out.println("long类型的最小值是:"+longMin);//-9223372036854775808
		
		//浮点型测试 float double
		//1.4E-45(1.4乘以10的负45次方)
		float floatMax = Float.MAX_VALUE;
		float floatMin = Float.MIN_VALUE;
		System.out.println("float类型的最大值是:"+floatMax);//3.4028235E38
		System.out.println("float类型的最小值是:"+floatMin);//1.4E-45
		
		double doubleMax = Double.MAX_VALUE;
		double doubleMin = Double.MIN_VALUE;
		System.out.println("double类型的最大值是:"+doubleMax);//1.7976931348623157E308
		System.out.println("double类型的最小值是:"+doubleMin);//4.9E-324
		
		//布尔型boolean true真 false假
		boolean b1 = true;
		boolean b2 = false;
		
		//字符型char
		char c1 = 'a';//可以保存一个字符
		char c2 = 97;//可以保存一个数字
		char c3 = '中';//可以保存一个汉字
		//char类型可以存数字,但是在打印时,会去查ASCII码表,把数字对应的字符拿出来使用
		//ASCII码表值规定了数组0-127对应的字符,128-65535默认按照字符?来处理
		System.out.println(c1);//a
		System.out.println(c2);//a
		System.out.println(c3);//中
	}
}

2.4 练习：求圆形的面积
需求:求出指定半径圆的面积

公式:圆的面积：π * r * r

创建包: cn.tedu.basic

创建类: TestCircleArea.java
package cn.tedu.basic;

import java.util.Scanner;

/**本类用于求圆的面积*/
public class TestCircleArea {
	public static void main(String[] args) {
		//公式:π*r*r
		//1.提示用户输入要求圆的半径
		System.out.println("请您输入要求圆的半径值:");
		//2.接收用户输入的半径值
		double r = new Scanner(System.in).nextDouble();
		//3.根据半径进行计算圆的面积
		double circleArea = 3.14*r*r;
		//4.把圆的面积打印到控制台
		System.out.println("当半径为"+r+"时,圆的面积为:"+circleArea);
	}
}

2.5 练习：变量交换

需求: 接收用户输入的两个值：假设a=1,b=2，并将这两个变量的值进行互换
创建包: cn.tedu.basic

创建类: TestValueExchage.java
package cn.tedu.basic;

import java.util.Scanner;

/**本类用于交换两个变量的值*/
public class TestValueExchage {
	public static void main(String[] args) {
		//1.提示并接收用于输入的两个值
		System.out.println("请输入a的值:");
		int a = new Scanner(System.in).nextInt();
		System.out.println("请输入b的值:");
		int b = new Scanner(System.in).nextInt();
		System.out.println("a的值:"+a);
		System.out.println("b的值:"+b);
		
		//2.交换a b 两个变量的值
		int t ;//定义用来值交换的第三方变量t
		t = a;//把a的值交给t来保存
		a = b;//把b的值交给a来保存
		b = t;//把t的值嫁给b来保存
		//3.把交换后的两个值打印在控制台
		System.out.println("交换后,a的值为:"+a);
		System.out.println("交换后,b的值为:"+b);
		
	}
}

2.6 引用类型
引用类型是一个对象类型，值是什么呢？它的值是指向内存空间的引用，就是地址，所指向的内存中保存着变量所表示的一个值或一组值。如：类，接口，数组,后面讲。。。

(后续会进一步学习,略…)
3 基本类型的字面值（5条）
3.1 整数字面值是int类型

int x = 99999;//对，右面数据的字面值是int类型
int x = 99999999999;//错，右面数据的字面值是int类型，但是已经超出int的取值范围。

3.2 byte，short，char三种比int小的整数可以用范围内的值直接赋值

byte b1=127;//对，
byte b2=128;//错，超出byte范围

3.3 浮点数的字面值是double类型

double r =3.14;//对
float r =3.14;//错，右面的数据字面值是double，float是4字节存不下double类型的数据

3.4 字面值后缀L D F

long x =99999999999L;//字面值是int类型,需转成long类型的数据,加字面值后缀L即可
float b = 3.0F;//3.0字面值是double类型，加后缀F会变成float类型
double d = 3D;//3字面值是int类型，加后缀D，会变成double类型

3.5 进制前缀

0b   - 标识这是2进制 ,如:0b0101
0    - 标识这是8进制, 8进制是三位,如: 023
0x   - 标识这是16进制,如: 0x0001
\u   -标识这是char类型，属于16进制

4  基本类型的类型转换
箭头开始的地方是小类型,箭头指向的地方是大类型

我们此处所指的"大"和"小",指的是对应类型的取值范围,不是字节数哦


4.1 小到大(隐式转换)

byte m = 120;
int n = m;//小转大,右面的m是小类型,给左面的n大类型赋值,可以直接使用
float  f = 3.2f; double d = f; -->可以执行

4.2 大到小(显式转换)
容量大的类型转换为容量小的类型时必须使用强制类型转换。

int x = 999;
byte y =(byte)x;//大转小,右面x给左面的y小类型赋值,不可以,需要强制类型转换


转换过程中可能导致溢出或损失精度

例如：int  i =128;   byte b = (byte)i; //打印的结果是-128

因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。
浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入

例如：float f = 32.7f;  int a2 =(int) f;    //打印的结果是32
不能对boolean类型进行类型转换。

4.3 口诀:
小到大，直接转 大到小，强制转 浮变整,小数没
低 ------------------------------------> 高
byte,short,char→ int→ long→float→double
5 运算规则（5条）
5.1 计算结果的数据类型，与最大数据类型一致

System.out.println(3/2);//1，int/int,得到的结果类型还是int
System.out.println(3/2d);//1.5，int/double。得到的结果是double

5.2 byte,short,char三种比int小的整数，运算时会先自动转换成int

byte a = 1;
byte b = 2;
byte c = (byte)(a+b);
//a+b会自动提升成int类型，右面得运算结果就是int大类型
//给左面的byte小类型赋值，不可以，需要强转。

5.3 整数运算溢出

整数运算，类似于一个钟表，转到最大时，再转会回到最小。

计算：光速运行一年的长度是多少米？3亿m/s

//溢出的现象：
//因为做了大的整型数据的运算，会超出int取值范围。解决方法：把整数提升成long类型。
System.out.println(300000000L * 60 * 60 * 24 * 365);

5.4 浮点数运算不精确

1-0.8 (这是一个现象,后续会学习解决方案)

5.5 浮点数的特殊值

Infinity 无穷大  3.14/0
NaN  not a number   0/0.0 或 0.0/0

6 拓展 标识符命名风格
1.【强制】标识符命名均不能以数字开头,而且下划线或美元符号开始，也不能以下划线或美元符号结束

错误案例：1name / _ name  /  name_   /  $ name  /  name $

2.【强制】代码中的命名严禁使用拼音与英文混合的方式，更不允许直接使用中文的方式。

说明：正确的英文拼写和语法可以让阅读者易于理解，避免歧义。

注意，即使纯拼音命名方式也要避免采用。

正确案例：alibaba / taobao / youku / hangzhou 等国际通用的名称，可视同英文。

错误案例：DaZheModule [打折模块] / getPingfenByName() [评分]

3.【强制】类名使用 UpperCamelCase 风格，即第一个单词的首字母就要大写

Java中的50个关键字
    关键字也称为保留字，是指java语言中规定了特定含义的标示符。对于保留字，用户只能按照系统规定的方式使用，不能自行定义。Java中有50个常用关键字：
与数据类型相关（10）
 
关键字
类型
占字节数
备注
boolean
布尔数据类型
1
有true和false两个值
int
整型数据类型
4
 
long
长整型数据类型
8
 
short
短整型数据类型
2
 
byte
字节数据类型
1
大小范围为-27—27-1
float
浮点型（实数型）
4
 
double
双精度型数据类型
8
 
char
字符型数据类型
2(Unicode码)
 
class
表示一个类
不确定
可用于定义一个类。
interface
表示一个接口
不确定
可用于定义一个接口
与流程控制相关（13）
if： 表示条件判断，一般用法if（关系表达式），后跟else或{……}
else： 条件转折，如if （关系表达式）{语句块1}else{语句块2}，如果关系表达式的值为true，则执行语句块1，否则执行语句块2.
do……while……：do和while一般一起使用，用于表示循环语句。do{……}while（关系表达式）……；当关系表达式的值为true是继续循环。
for：用于表示循环，for循环是最常使用的循环，格式for（表达式a; 表达式b; 表达式c）括号里面的书通常用于控制循环的次数，一般会用一个int类型的变量类计数，如（int
 i=0; i<10; i++）表达式a用于流程控制的开始值，表达式b表示循环终止条件，表达式c用于计数。
switch（条件a）case……：switch和case合起来用于表示条件分支流程。如：

while(int c) {

case 1: {语句块1} 

case 2: {语句块2}

……?????? ……

case n: {语句块n}

default：exit(0);

}
如果c为1，则执行语句块1；如果c为2，则执行语句块2；以此类推，如果c为n，则执行语句块n。default表示除case以外出现的情况。
default：在switch……case……分支语句可知，default是在所有case条件下都不成立时使用。用于包表示s“rc”文件夹下的当前包；如果用于类，表示只可被本文件内的其它类访问。
break：用于结束本层循环，或跳出某层循环。
continue：用于跳出本次循环，而break跳出本层循环。Break和continue可以实现类似于C\C++中goto语句的用法：

label0:

{

　for (int k = 0; k < 10; k++) {

　.......... 

　label1:

　for (int j = 0; j < 10; j++) {

　　................

　　break label0;　　//跳转至label0

　}

　...........

　label2:

　for (int kk = 0; kk < 10; kk++) {

　　..............

　　break label0;　　//跳至label2
　}

}
return:返回一个值，通常用于函数中，返回一个具有特定类型的值。如:
public int fuction()
{
　　int a; 
　　……
　　return a;//返回int型的值
}

try……catch……finally……：用于异常处理，使用形式如：
try{

　……

}catch(类型b){

　……

}finally{

　……

}
try{……}中放置可能会发生异常的的语句块，catch(){……}用于抓住异常，{}定义当出现异常时的处理方法。finally{……}表示不管异常是否发生，都得进行finally{}中的处理。
与修饰符相关（12）
不同访问修饰符的访问权限
范围
本类
同软件包
不同包中子类
不同包且无继承
作用(含义)

public
可以
可以
可以
可以
公有的

protect
可以
可以
可以
 
受保护的

default(无权限修饰符)
可以
可以
 
 
当前的

private
可以
 
 
 
私有的
如：
一个".java"后缀名的文件里面只能一个publi型的cass类。如c13.swing包下有HelloWorld.java 文件，该文件下有如下代码：
package c13.swing;
public class HelloWorld {
	public void show() {
		System.out.println("HelloWorld!");
	}	
}
在default包下有如下代码：
import c13.swing.*;//引入所需要的包里的所有类
public class Test {
	public static void main(String args[]) {
		HelloWorld h = new HelloWorld();
		h.show();
	}
}
此时运行正常，结果：HelloWorld!
如果把public class HelloWorld改成privateclass HelloWorld则会运行错误，因为private是私有的不能被其他包内的对象所引用。
final：(类似于C++中的const)，用法如下：

a，final的变量的值不能被改变；1），final的成员变量； 2）final的局部变量；

b，final的方法不能被重写；

c，final的类不能被继承。
void：空类型，用于函数前表示空返回值。
static：可用于定义静态成员变量或方法
strictfp：意思是FP-strict，也就是说精确浮点的意思。在Java虚拟机进行浮点运算时，如果没有指定strictfp关键字时，Java的编译器以及运行环境在对浮点运算的表达式是采取一种近似于我行我素的行为来完成这些操作，以致于得到的结果往往无法令你满意。而一旦使用了strictfp来声明一个类、接口或者方法时，那么所声明的范围内Java的编译器以及运行环境会完全依照浮点规范IEEE-754来执行。因此如果你想让你的浮点运算更加精确，而且不会因为不同的硬件平台所执行的结果不一致的话，那就请用关键字strictfp。  

你可以将一个类、接口以及方法声明为strictfp，但是不允许对接口中的方法以及构造函数声明strictfp关键字，例如下面的代码： 
1. 合法的使用关键字strictfp 

strictfp interface A {}
public strictfp class FpDemo1 { 

strictfp void f() {} 

} 

2. 错误的使用方法 

interface A { 

strictfp void f(); 

}
public class FpDemo2 { 

strictfp FpDemo2() {} 

}
一旦使用了关键字strictfp来声明某个类、接口或者方法时，那么在这个关键字所声明的范围内所有浮点运算都是精确的，符合IEEE-754规范的。例如一个类被声明为strictfp，那么该类中所有的方法都是strictfp的。
abstract：抽象的意思，可以用定义抽象类，抽象函数。抽象类的用法规则如下：

a，用abstract关键字来修饰一个类时，这个类叫做抽象类；用abstract来修饰一个方法时，这个方法叫做抽象方法；

b，含有抽象方法的类必须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写；

c，抽象类不能被实例化；

d，抽象方法只需声明，而不需实现。
transient: Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。

 使用对象：字段

介绍：字段不是对象持久的一部分，不应该字段和对象一起串起。
synchronized：锁定当前对象，在执行当前这个对象时不应许其他线程打断插入。使用的方式有：
这是我在暑假学习做的笔记
（1），class Timer {

private static int num = 0;

public synchronized void add(String name) { //执行这个方法的过程中锁定当前对象。

num ++;

try {

Thread.sleep(1);

} catch( InterruptedException e) {

return;

}

System.out.println(name + ",你是第" + num +"使用Timer的线程。");

}

}

（2），class Timer {

private static int num = 0;

public void add(String name) { 

synchronized(this) { //锁定大括号这个区域的代码段

num ++;

try {

Thread.sleep(1);

} catch( InterruptedException e) {

return;

}

System.out.println(name + ",你是第" + num +"使用Timer的线程。");

}

}

}
volatile：volatile变量一个时间只有一个线程可以访问。 保证线程安全。 

可以被写入 volatile 变量的这些有效值独立于任何程序的状态，包括变量的当前状态。 

所以，Volatile 变量是一种非常简单但同时又非常脆弱的同步机制，它在某些情况下将提供优于锁的性能和伸缩性。
native：是用作java 和其他语言（如c++）进行协作时用的也就是native 后的函数的实现不是用java写的， native的意思就是通知操作系统，这个函数你必须给我实现，因为我要使用。所以native关键字的函数都是操作系统实现的，
 java只能调用。
与动作相关（10）
package：打包，把java程序写在一个包中。
import：引入报名，用法： 

a，写全包名：jsxt.java140.Cat c = new com.bjsxt.java140.Cat

a，引入一个包中的具体某个对象：xt.java140.Cat;

b，引入一个包中的所有象：import com.bjsxt.java140.Cat.*;
throw：抛出用户自己定义的异常
throws：抛出系统异常
extends：继承（类继承类，或接口继承接口）
implements：实现，通过类来实现接口
this：是指向该对象自身的标示符
super：调用基类的构造函数
instanceof：判断某个对象是否为自己所要的对象
new：用于新建一个对象，即类的实例化
其他（5）
true：表示boolean类型的真值
false：表示boolean类型的假值，即不成立的情况
null：表示空值，如果是对象，则表示此对象为空，如果是数据类型，在表示相应数据类型的默认值，如int的默认值为0。
goto：C\C++中实现无条件转向语句，为了结构化程序设计java中现在一般不用。
const：和const一样，在Java中,const是作为保留字以备扩充。可以用final替换const，一般C++中用const，java中用final。