JavaSE是学习JavaWeb、JavaEE以及Android开发的基础
边听边思考边做“笔记”
不要完全依赖书和视频；
捷径：敲、狂敲；
规范：加注释；
难点，不懂的记录下时间再回头看；
在敲代码中学习知识点，加深知识的理解。
软件开发：
软件，即一系列按照特定顺序组织的计算机数据和指令的集合。分为系统软件和应用软件。
人机交互方式：
图形化界面（Graphical User Interface GUI）这种方式简单直观，使用者易于接受，容易上手操作。
命令行方式（Command Line Interface CLI）:需要有一个控制台，输入特定的指令，让计算机完成一些操作。需要记住一些命令。
常用的DOS命令
dir：列出当前目录下的文件以及文件夹
mid：创建目录
rd：删除目录
cd：进入特定目录
cd..：退回到上一级目录
cd\：退回到根目录
del：删除文件
exit：退出dos命令
echo javase >1.doc
C:\Users\Administrator>d: D:\>directory ‘directory‘ 不是内部或外部命令，也不是可运行的程序 或批处理文件。 D:\>dir 驱动器 D 中的卷没有标签。 卷的序列号是 0004-E52B D:\ 的目录 2018/11/04 22:47 <DIR> 140415 2018/11/04 19:22 <DIR> BaiduYunDownload 2018/07/21 15:31 <DIR> centos7 2018/11/05 10:26 <DIR> code 2018/06/08 20:39 <DIR> Git 2017/11/28 11:34 <DIR> photoshop_cs6_33lc 2018/11/05 10:55 <DIR> Program Files 2018/09/26 20:58 <DIR> Program Files (x86) 2018/05/12 08:44 <DIR> WebStorm 2018.1.3 2018/08/03 22:06 <DIR> WeChat 2017/01/11 22:56 510,835,180 文件.rar2018/07/21 15:33 <DIR> 虚拟机 1 个文件 510,835,180 字节 12 个目录 113,653,895,168 可用字节 D:\>md 1130 #创建文件夹 D:\>cd 1130 #切换到这个文件目录下 D:\1130>md team1 #创建文件 D:\1130>md team2 D:\1130>cd.. #退出1层目录 D:\>cd 1130/team1 #进入多层目录 D:\1130\team1>cd.. D:\1130>cd/ #退出到根目录 D:\>cd 1130\team1 D:\1130\team1>echo name:kris sex:male > 1.txt #创建文件并写入内容 D:\1130\team1>echo >1.doc D:\1130\team1>cd.. D:\1130>rd team2 #删除目录 D:\1130>rd team1 目录不是空的。 D:\1130>cd team1 D:\1130\team1>del 1.doc #删除文件 D:\1130\team1>del *.doc 找不到 D:\1130\team1\*.doc D:\1130\team1>cd.. D:\1130>del team1 D:\1130\team1\*, 是否确认(Y/N)? y D:\1130>rd team1 D:\1130>
计算机语言：
语言：人与人沟通的一种方式。中国人要和英国人交流就要学习英语。（更多的是一种形象思维）
计算机语言：人与计算机交流的方式。人与计算机交流就要学计算机语言，如C、C++、java、php等。
C语言主要用来写操作系统，也可写应用软件，但超过十万行代码的用的就比较少了，它对异常处理机制、错误处理做的不好；它不是面向对象的，虽然有很好的运行效率
； C++具有一些面向对象的特性，社区的回复性也很高，但它不是跨平台的；
Java是跨平台的；C#跨平台性、面向对象都有，它是微软搞出来的。
重量型（C、java、objective--C、C++、C#）注重运行效率，功能性；、轻量型级别（PHP、python、JavaScript、Visual Basic .NET）讲究开发的效率，可移植性、跨平台性较差。
特点一：面向对象
两个基本概念：类、对象
三大特性：封装、继承、多态
提供类、接口和继承等原语，为了简单起见，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为implement）。
特点二：分布式
支持Interner应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括URL、URLConnection、Socket、ServerSocker等。Java的RMI（远程方法激活）机制也是开发分布式应用的重要手段。
特点三：健壮性
吸收了C/C++语言的优点，但去掉了其影响程序健壮性的部分（如指针、内存的申请与释放等），提供了一个相对安全的内存管理和访问机制。
强类型机制、异常处理、垃圾的自动收集等是Java程序健壮性的重要保证。
特点四：跨平台性
跨平台性：通过java语言编写的应用程序在不同的系统平台上都可以运行。“ Write once , Run Anywhere ”；
原理只要在需要运行java应用程序的操作系统上，先安装一个Java虚拟机（JVM Java Virtual Machine）即可。由JVM来负责程序在该系统中的运行。
JAVA程序 -- win版JVM（windows操作系统）、linux版的JVM（Linux操作系统）、Mac版的JVM（Mac操作系统）
因为有了JVM，同一个Java程序在三个不同的操作系统中都可以执行。这样就实现了Java程序的跨平台性。
Java SE(Java Standard Edition)Java标准版
支持面向桌面级应用（如Windows下的应用程序）的Java平台，提供了完整的Java核心API，此版本以前称为J2SE
Java EE(Java Enterprise Edition)Java企业版
是为开发企业环境下的应用程序提供的一套解决方案。该技术体系中包含的技术如:Servlet 、Jsp等，主要针对于Web应用程序开发。
Java ME(Java Micro Edition)Java小型版
支持Java程序运行在移动终端（手机、PDA）上的平台，对Java API有所精简，并加入了针对移动终端的支持，此版本以前称为J2ME
Java Card
支持一些Java小程序（Applets）运行在小内存设备（如智能卡）上的平台
JDK（Java Development Kit Java开发工具包） JDK = JRE + 开发工具包
JDK是提供给开发人员使用的，包含了Java的开发工具（编译工具（javac.exe）打包工具（jar.exe）等），也包括了JRE。
JRE（Java Runtime Environment Java运行环境） JRE = JVM + JavaSE标准类库
包括Java虚拟机（JVM Java Virtual Machine）和Java程序所需的核心类库等，如果想运行一个开发好的java程序，只需安装JRE即可。
简单而言，使用JDK的开发工具完成的java程序，交给JRE去运行。
JVM Java Virtual Machine java虚拟机
JDK是包含JRE的，JRE java运行式环境，仅仅是用来运行，它里边包含Java虚拟机以及所需的主要库；
做测试，只需安装JRE就可以了；
include是示例，jre整个运行式环境，bin涉及一些命令；命令对应的代码在lib里边；bin可执行文件（javac编译、java运行）
配置环境变量，就是可以在任何目录下运行；
class HelloWorld{ //这是main方法，它是程序的入口 public static void main(String[] args){ /* 这是程序的输出语句，格式是如下的样子： System.out.println(); */ System.out.println("Hello Java!"); //ln就表示换行，print是不换行 } }
D:\code\day01>javac HelloWorld.java //编译之后就会出现HelloWorld.class的文件 D:\code\day01>java HelloWorld //类名 Hello Java!
public class HelloJava{ /* 1.源文件以.java结尾； 2.源文件中可以有多个class声明的类； 3.类中可以有主方法（即main()方法，其格式是固定的：public static void main (String[] args){} 4.main()方法是程序的入口，方法内是程序的执行部分； 5.一个源文件中只能有一个声明为public的类，同时要求此类的类名与源文件名一致。 6.每个语句都以";"结束 7.执行程序:编译:javac.exe ,编译完生成诸多个.class字节码文件；运行:java.exe */ public static void main(String[] args) { System.out.println("Hello World!"); } } class Person{ } class Hello{ }
注释：
提高代码的阅读性，调试程序的重要方法。有单行注释、多行注释、文档注释（java特有）。将自己的思想通过注释先整理出来，再用代码去体现。（良好的编程习惯）
多行注释不能嵌套
文档注释（java特有）
格式：
/** *@author 指定java程序的作者 *@version 指定源文件的版本 *@param 方法的参数说明信息。 */
注释内容可以被JDK提供的工具javadoc所解析，生成一套以网页文件形式体现的该程序的说明文档。
操作方式：
D:\code\day01>javadoc -d mydoc -author -version HelloJava.java
D:\code\day01>javadoc -d mydoc -author -version HelloJava.java 正在加载源文件HelloJava.java... 正在构造 Javadoc 信息... 正在创建目标目录: "mydoc\" 标准 Doclet 版本 1.8.0_192 正在构建所有程序包和类的树... 正在生成mydoc\HelloJava.html... 正在生成mydoc\package-frame.html... 正在生成mydoc\package-summary.html... 正在生成mydoc\package-tree.html... 正在生成mydoc\constant-values.html... 正在构建所有程序包和类的索引... 正在生成mydoc\overview-tree.html... 正在生成mydoc\index-all.html... 正在生成mydoc\deprecated-list.html... 正在构建所有类的索引... 正在生成mydoc\allclasses-frame.html... 正在生成mydoc\allclasses-noframe.html... 正在生成mydoc\index.html... 正在生成mydoc\help-doc.html... D:\code\day01>
API
源码：
D:\Program Files\Java\jdk1.8.0_192\src.zip 在这个压缩包里边，把它的代码给抽取出来就是我们看到的API，类--下面的一些方法；
文档中英文结合地看；
关键字、标识符、变量（基本数据类型和基本数据类型转换）、运算符、程序流程控制、数组
定义：被java语言赋予了特殊含义，用做专门用途的字符串（单词）； 特点：关键字中所有字母都是小写；
用于定义数据类型的关键字：
class、interface、enum、byte、short、int、long、float、double、char、boolean、void
用于定义数据类型值的关键字：
true、false、null
用于定义流程控制的关键字：
if、else、switch、case、default、while、do、for、break、continue、return
用于定义访问权限修饰符的关键字：
private、protected、public
用于定义类，函数，变量修饰符的关键字：
abstract、final、static、synchronized
用于定义类与类之间关系的关键字：extends、implements；
用于定义建立实例及引用实例，判断实例的关键字：new、this、super、instanceof
用于异常处理的关键字：try、catch、finally、throw、throws
用于包的关键字：package、import
其他修饰符关键字：native、strictfp、transient、volatile、assert
java保留字：现有Java版本尚未使用，但以后版本可能会作为关键字使用。自己命名标记符时要避免使用这些保留字。
byValue、cast、future、generic、inner、operator、outer、rest、var、goto、const
Java对各种变量、方法和类等要素命名时使用的字符串系列成为标识符。 凡是自己可以起名字的地方都叫标识符。
定义它的规则：
①由26个英文字母大小写，0--9，_或$组成；②数字不可以开头；
③不可以使用关键字和保留字，但能包含关键字和保留字；
④ Java中严格区分大小写，长度无限制。
⑤中间不能有空格
标识符的命名规范：
1、见名知意
2、类名、接口名：每一个单词的首字母大写，形式：XxxYyyZzz
3、变量名、方法名：从第二个单词开始，首字母大写，形式：xxxYyyZzz
例如：main, getName, age, myAge
4、包名：所有单词都小写，单词之间使用.分割，形式：xxx.yyy.zzz
例如：java.util，java.sql，java.lang，java.net
5、常量名：所有单词都大写，单词之间使用_分割，形式：XXX_YYY_ZZZ
例如：PI，MAX_VALUE，MAX_PRIORITY
53个关键字、保留字、特殊值：都是小写。
变量：存储值、访问值； 用一个固定的名字，代表一个会变的值。
变量：本质上代表内存中的一块存储区域（该区域有自己的名称（变量名）和类型（数据类型）），这块存储区域中的值是可变的。
变量有三个要素：
（1）数据类型 比喻房间的类型，单人间，双人间，总统套房
（2）变量名 比喻房间号，302,312
（3）变量值 比喻房间中的人，张三，李四
变量的使用有要求：
（1）先声明后使用
如果一个变量没有声明：
TestVariable.java:27: 错误: 找不到符号
（2）在使用之前，必须先初始化
使用：包括计算、打印值
（3）变量有作用域
A：同一个作用域中，变量不能重复声明，可以重复赋值
B：出了作用域，变量就无法访问了
作用域：从声明处开始，到它所属的{ }结束
该区域的数据可以在同一类型范围内不断变化；
定义变量的格式：数据类型 变量名 = 初始化值
对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。
Java各整数类型有固定的表数范围和字段长度，不受具体OS的影响，以保证java程序的可移植性。
整型常量默认为 int 型，声明long型常量须加 ‘ l ’ 或 ‘ L ’
②浮点类型
浮点型： float：单精度浮点型,占4个字节 大概科学记数法的表示方式，小数点后7~8位 double：双精度浮点型,占4个字节 大概科学记数法的表示方式，小数点后15~16位
char：字符类型，Java是存储每一个字符的Unicode编码值，2个字节 世界上所有的字符、标点符号都会有一个唯一的Unicode编码值。 A：65 B：66 a：97 b：98 0：48 1：49 尚：23578(十进制) Unicode的数字值占个字节，但是在网络中传输、文件中保存实际占几个字节，要看编码方式：GBK，每一个汉字都是2个字节UTF-8，每一个汉字基本上是3个字节，也有特殊的。 char字符的表示方式： （1）‘a‘,‘男‘,‘;‘ 字符常量是用单引号（‘ ’）括起来的单个字符，涵盖世界上书面语的字符， 例如：char c1 = ‘a‘；char c2 = ‘中‘；char c3 = ‘9‘； （2）‘\n‘,‘\t‘,‘\b‘ 转义字符。Java中还运行使用转义字符 ‘ \ ’来将其后的字符转变为特殊字符型常量。例如：char c3 = ‘ \n ‘； // ‘\n‘表示换行符。 （3）‘\u5c1a‘ 十六进制。直接使用Unicode值来表示字符型常量：‘\uXXXX’。其中，XXXX代表一个十六进制整数，如：\u000a 表示\n。
char类型是可以进行运算的。因为它都对应有Unicode码。
转义字符
\b 退格键
\n 换行符
\r 回车符
\t 制表符
\" 双引号
\‘ 单引号
\\ 反斜杠
适于逻辑运算，一般用于流程控制：
if条件语句； while循环控制语句； do-while循环控制语句； for循环控制语句；
boolean 类型数据只允许取值true和false，无null；不可以0或非0的整数替代false和true，这点和C语言不同。
引用数据类型： 类、：例如：String,System，Object，Math，File,Date,Scanner..... 接口：Runnable、Serializable、Comparable.... 数组：int[],String[],char[]....
//变量: 基本数据类型(8个) vs 引用数据类型(类、接口、数组) //1.java中的变量定义的格式: 数据类型 变量名 = 初始值 class TestVeriable{ public static void main(String[] args) { //2.变量先定义,后使用 int myInt1 = 10; double d1 = 12.3; System.out.println(myInt1); System.out.println(myInt1 + d1); //i1超出了其作用范围，不可使用。 //System.out.println(i1); //3.整型:byte(-128~+127) short int(默认类型) long byte b1 = 12; byte b2 = 127; short s1 = 128; int i1 = 12; //定义long型变量，值的末尾加"L"或"l" long l1 = 12324321L; System.out.println(l1); //4.浮点型(带小数点的数值):float double(默认类型) double d11 = 12.3; //声明float类型的浮点型数据,末尾要加"F"或者"f" float f1 = 12.3F; System.out.println(f1); //5.字符型(=两个字节): char 只能表示一个字符(英文、中文，标点符号等) char c1 = ‘a‘; //char c2 = ‘ab‘; String str = "ab"; char c3 = ‘中‘; String str1 = "中国"; //可以表示转义字符 char c4 = ‘\t‘; char c5 = ‘\n‘; System.out.println("abc" + c5 +"def"); char c6 = ‘\u1234‘; System.out.println(c6); //6.布尔类型: boolean 只能够取值true 或 false,不能取值null boolean bool1 = true; if(bool1){ System.out.println("你看帅哥!"); }else{ System.out.println("没看到!"); } } public void method1(){ int i1 = 10; System.out.println(i1); } }
十进制的int 1234（4*8，4个字节 32位） --->>二进制的2个字节 给它转换成byte类型，那就会剩下8个了，截断高位的；
by1 为57
111001转换为十进制
/* 变量之间的运算:（不考虑boolean,剩下char(都对应unicode的一个值) byte short int long float double) 1.自动类型转换 2.强制类型转换 */ class TestVeriable1{ public static void main(String[] args) { //1.自动类型转换:当容量小的数据类型与容量大的数据类型做运算时,容量小的会自动转换为 //容量大的数据类型:char,byte,short==>int==>long==>float==>double int i1 = 12; //4个字节 short s1 = 2; //2个字节 int i2 = i1 + s1; //4个字节 float f1 = 12.3F; float f2 = f1 + i2; double d1 = f2 + 12.3;//默认12.3为double类型,8个字节,如果用float就错了 long l = 12L; //long l = 12; 默认为int类型,赋值给l也是可以的,int范围比long的小 float f3 = l; //这种形式的也可以.用的是科学计数法 char c1 = ‘a‘;//97 c1 = ‘A‘;//65 int i3 = c1 + 1; System.out.println(i3); System.out.println(i2); System.out.println(f2); //需要主意的:当char\byte\short之间做运算时,默认的结果为int类型 short ss1 = 12; byte bb1 = 1; char cc1 = ‘a‘; //short ss2 = ss1 + bb1; 错误的 int ii1 = ss1 + bb1; //char cc2 = cc1 + bb1; 错误的 int ii2 = cc1 + bb1; short ss2 = 11; //short ss3 = ss1 + ss2 //2.强制类型转换:容量大的转换为容量小的 //强制类型转换的问题:导致精度的损失 long l1 = 12345L; int m1 = (int)l1; System.out.println(m1); byte by1 = (byte)m1; System.out.println(by1); //3. 平时常用的字符串,也是一种数据类型：String String nation = "我是一个中国人"; System.out.println(nation); //字符串与数据类型之间的运算:只能是连接运算: + ,得到的结果仍为一个字符串 String str = "abc"; String str1 = str + m1; //abc12345 //String.out.println(str1); 这里为什么说找不到符号?????????????????? m1?? //题目： String str11 = "Hello"; int myInt1 = 12; char ch1 = ‘a‘; //97 "a"??????为什么会报错?? ‘a‘就不会， System.out.println(str11 + myInt1 + ch1);//Hello12a System.out.println(myInt1 + ch1 + str11);//109Hello System.out.println(ch1 + str11 + myInt1);//aHello12 } }
进制
最高位叫符号位；
正数符号位为0，负数的符号位为1； 在底层都是以补码的形式存的；
十进制转换二进制
运算符
//测试算术运算符: + - * / % ++ -- 连接符+ class TestAri{ public static void main(String[] args) { //除: / int i = 12; int j = i/5; double d = i/5; double d1 = i/5.0; //int类型除以double类型 System.out.println(j); //2 System.out.println(d); //2.0 System.out.println(d1);//2.4 //取模: %:取余数，结果的符号取决于被模数 int i1 = 12 % 5; int i2 = -12 % 5; int i3 = 12 % (-5); int i4 = -12 % (-5); System.out.println(i1);//2 System.out.println(i2);//-2 System.out.println(i3);//2 System.out.println(i4);//-2 //前++：先自增1，后做运算; //后++：先做运算，后自增; int myInt1 = 10; int myInt2 = myInt1++; //后++ System.out.println(myInt1); //11 System.out.println(myInt2); //10 int myInt3 = 10; int myInt4 = ++myInt3; //前++ System.out.println(myInt3);//11 System.out.println(myInt4);//11 //前--：先自减1，后做运算; //后--：先做运算，后自减; } }
左右两端都是布尔类型的
//逻辑运算符 ： & && | || ! ^ class TestLogic{ public static void main(String[] args) { boolean a = true; boolean b = false; System.out.println(a & b); //false System.out.println(a && b);//false System.out.println(a | b); //true System.out.println(a || b); //true System.out.println(a & !b); //true System.out.println(a^b); //true //& 与 &&的区别: &不管左边是true还是false,右端都会进行运算; // &&当左端为false时,右端不再进行运算; // 以后使用时,建议使用&& int i1 = 10; if(b & (i1++) > 0){ System.out.println("今天天气好暖和啊"); }else{ System.out.println("难得没有雾霾"); } System.out.println(i1);//11 int i2 =10; if(b && (i2++) > 0){ System.out.println("今天天气好暖和啊"); }else{ System.out.println("难得没有雾霾"); } System.out.println(i2);//10 //| 与 ||的区别: | 当左端为true时,右端照样做运算; // ||当左端为false时,右端不再进行运算; // 以后使用时,建议使用|| int i3 = 10; if(a | (i3++) > 0){ System.out.println("今天天气好暖和啊"); }else{ System.out.println("难得没有雾霾"); } System.out.println(i3);//11 int i4 =10; if(a || (i4++) > 0){ System.out.println("今天天气好暖和啊"); }else{ System.out.println("难得没有雾霾"); } System.out.println(i4);//10 } }
左右两端都是数值类型的
右移，就看你原来的那个数最高位是0还是1，是0的拿0补，是1的拿1补；
class TestExer1 { public static void main(String[] args) { int m = 12; int n = 5; System.out.println("m:" + m + "n:" + n); //方法一:提供一个临时变量; //int temp = m; // m = n; // n = temp; //System.out.println("m:" + m + "n:" + n); //方法二:当m和n较大时,有可能出现精度损失; //m = m + n;// m = 12 + 5; //n = m - n;// m = 17 - 5; //m = m - n;// m = 17 - 12; //System.out.println("m:" + m + "n:" + n); //方法三:优点:没有上面两种方法的缺点 m = m ^ n; n = m ^ n; //(m ^ n) ^ n == m m = m ^ n; //(m ^ n) ^ m == n System.out.println("m:" + m + "n:" + n); //60 手动的方式,从控制台输出60的十六进制. int i = 60; //操作 System.out.prinln();//3c } }
//60 手动的方式,从控制台输出60的十六进制. int i = 60; //自动调用Integer类现成的方法 String binary = Integer.toBinaryString(i); //变成二进制 System.out.println(binary); //111100 String hex = Integer.toHexString(i); System.out.println(hex);//3c /* char c = ‘a‘; char c1 = (char)(c + 2); System.out.println(c1); //c */ int j = i & 15; //获取到i的最低4位对应的值。 String k1 = (j <= 9)?j + "" : (char)(j - 10 + ‘a‘) + ""; //System.out.println(k1);//c i = i >> 4; int z = i & 15; String k2 = (z <= 9)? z + "" : (char)(z - 10 + ‘a‘) + ""; System.out.println(k2 + k1);
/* 三元运算符:(表达条件式) ? 表达式1 : 表达式2； 要求:表达式1与表达式2为同种数据类型。 既然是运算符，就一定会有运算结果，结果的数据类型与表达式1,2的类型一致。 三元运算符在一定程度上可以与if-else互换(三元运算符一定可以转换为if-else,反之不成立。) */ class TestSanYuan{ public static void main(String[] args) { int i = 20; int j = 20; //此时max记录了i与j的较大值 int max = (i > j)?i : j; //String str = (i > j) ? "i大" : "j大"; String str = (i > j)? "i大" : (i == j)? "相等" : "j大"; //String str1 = (i > j)? i : "j大"; System.out.println(max); System.out.println(str); //互换 if(i > j){ System.out.println("较大值为:" + i); }else{ System.out.println("较大值为:" + j); } //练习:如何使用三元运算符，输出三个数中的较大值 int m = 12; int n = 23; int k = -9; int max1 = (m > n)? m : n; int max2 = (max1 > k)? max1 : k; System.out.println(max2); } }
原文：https://www.cnblogs.com/shengyang17/p/9908469.html