java的编译和执行指令
HelloWorld.java
javac HelloWorld.java -> 编译生成 HelloWorld.class（字节码文件）
java HelloWorld -> 执行HelloWorld类
java的命名规则和规范
类，方法，属性，变量统称为标识符
标识符起名规则
首字符可以是字母,_和$
其余字符可以是字母，_, $和数字
名字中间不能出现空格
不能使用关键字和保留字作为标识符
保留字：goto const
关键字：public class static void.....
标识符的起名规范
类名： 首字符大写，其余每个单词首字母都大写 Studnet StudentClass
方法名：首字符小写，其余每个单词首字母都大写 student studentClass
属性名/变量名：规则与方法名一致
二进制十进制转换
二进制 -> 十进制
10010 = 2*2*2*2 + 2 = 18
十进制 -> 二进制
20 0
10 0
5 1 => 10100
2 0
1
数据类型的取值范围
基本类型 1Byte = 8bit 1bit = 0/1
byte 1Byte 7bit -2的7次幂 - 2的7次幂-1 -128 - 127
short 2Byte 15bit -2的15次幂 - 2的15次幂-1 -32768 - 32767
int 4Byte
long 8Byte
float 4Byte
double 8Byte
char 2Byte
boolean 1Byte
字符和字符串的区别
char c = 'A' -- 字符 使用单引号 基本数据类型
String str = "ABC" -- 字符串 使用双引号 引用数据类型
haha('A'); -- 传入的是字符
public void haha(int c)
public void haha(String s)
类型转换
基本数据类型的转换
自动转换
byte
short -> int -> long -> float -> double
char
boolean
自动转换的规律
(1)小的范围向大的范围自动转换
(2)整数向浮点数自动转换
(3)char向int自动转换
(4)boolean不参与任何转换
强制转换
语法 double d = 3.14;
int i = (int)d;
强制转换丢失精度
(1)浮点数向整数强制转换，丢失小数部分
(2)大的范围向小的范围强制转换，丢失bit位的数据
int i = 300; 100101100
byte b = (byte)i; 00101100
b? 44
引用数据类型的转换
没有继承或实现关系的两个类之间是不能进行类型转换的
继承或实现关系的两个类之间
上溯造型
子类可以自动转换成父类对象
class Child extends Parent
Parent p = new Parent();
Child c = new Child();
p = c;
下溯造型
父类对象向子类对象进行强制转换（该父类对象必须是该子类对象先转过去）
class Child extends Parent
Parent p = new Parent();
Child c = new Child();
c = (Child)p; //编译通过，执行时会报出类型转换异常
Parent p = new Child();
Child c = (Child)p; //没有问题 OK的
单目运算符++
int x = 3;
int y = x++/2; 3/2 = 1
int x = 3;
int y = ++x/2; 4/2= 2
int x = 3;
int y = 5;
y += x++; y += 3 8
逻辑运算符的短路
&& ||
int x = 3;
boolean b = (x++ > 3) && (++x < 5);
3 > 3
4
x? 4
&，|不是短路的，通常用于位运算
条件分支和循环
int x = 0;
while(x>0){
sysout("xxx");
x++;
}
结论：x = 0 控制台什么都不输出
int x = 0;
do{
sysout("xxx");
}while(x>0);
结论：x=0 控制台输出“xxx”
while与do...while的区别
while有可能循环体中的代码一次都不执行
do...while至少会执行一次方法体中的内容
数组的声明和创建
一维
int[] a = new int[3];
int[] a = new int[]{1,2,3};
int[] a = {1,2,3};
int a[] = {1,2,3};
二维
int[][] a = new int[3][4];
int[][] a = new int[3][];
int[][] a = new int[][4]; 错误！！
int[][] a = new int[3][4];
a.length ? 3
a[0].length ? 4
冒泡排序
类的属性和方法
属性：代表类的一个属性和状态，声明在类中的变量
方法：代表类中的一个行为
类的声明和实例化
构造方法来完成实例化
类不写构造方法 -- 系统默认提供无参构造方法
类写明了构造方法 -- 系统不再提供了
构造方法是可以重载的
this的使用
1.解决方法中同名变量/同名参数与属性冲突
private String name;
public Haha(String name){
this.name = name;
}
2.在构造方法中调用本类的其他构造方法（必须写在构造方法的第一行）
private String name;
public Haha(){
this("张三");
}
public Haha(String name){
this.name = name;
}
方法重载
重载：同名，不同参数，返回值类型无关的方法
继承
一般（父类）与特殊（子类）的关系
ISA原则 XXX是一种YYY 成立 XXX就是YYY的子类
super
1.调用继承来的父类的属性和方法（可以被this替代）
Class Parent{
public String name;
}
Class Child extends Parent{
public Child(String name){
super.name = name; <=> this.name = name;
}
}
2.调用父类的构造方法
Class Parent{
public String name;
public Parent(String name){
this.name = name;
}
}
Class Child extends Parent{
public Child(String name){
super(name); // 此处父类没有无参构造方法，子类必须显式的调用父类构造方法
}
}
抽象类
abstract类 -- 本质上抽象类就是当父类
抽象类中可以有普通方法，也可以有抽象方法。什么方法都没有也行
抽象方法：没有方法体，子类来实现抽象方法。
接口
interface 接口
implements 实现接口
接口中定义的方法都是抽象方法
哪些关键字可以写在接口文件中？
public
abstract
final
extends 接口可以继承其他接口 多继承
class 可以写
implements 不能写！！！
类与接口的关系
类与类之间 单继承关系
类与接口之间 多实现关系
接口与接口之间 多继承关系
接口与类之间 没有关系
接口与抽象类的区别
抽象类是class 接口是interface
抽象类中可以有正常的属性和普通的方法
接口中的方法必须全部是抽象方法 （可以省略public 和 abstract）
抽象类被其他类单继承
接口可以被其他类多实现，也可以被其他接口多继承
封装
访问权限
private 默认 protected public
private 私有 类自身的内部
默认 包 同包下的其他类
protected 保护 同包下及不同包的子类
public 公有 任何类都可以访问
部分权限
setter和getter方法
只读权限：
属性私有
只设置get方法
多态
重写
子类改写父类同名同参同返回值类型的方法，访问权限子类>=父类
重载与重写的区别
父类引用子类实例化
实例题：参照上次周测分析题
Class Parent{
public void haha(){
sysout("Parent")
}
}
Class Child extends Parent{
public void haha(){
sysout("Child")
}
}
main(){
Parent p = new Child();
p.haha(); ==> Child
}
static关键字
静态关键字：所有对象共享一个内容
块
static{
//块
}
当第一次加载该类时，static块中代码执行一次，以后不再执行
在整个程序运行周期中，最多只执行一次
属性 被称为类属性
class Haha{
static int i
所有对象共享该属性
}
Haha h1 = new Haha();
Haha h2 = new Haha();
h1.i = 5;
h2.i = 10;
h1.i? 10
正常的调用方式
Haha.i = 5;
Haha.i = 10;
方法 被称为类方法
无需创建对象即可调用
class Haha{
static int i;
int j;
所有对象共享该属性
static void abc(){
sysout(i);
sysout(j); --编译失败
}
}
Haha.abc();
静态方法需要注意:
1.静态方法可以直接调用类中的其他静态方法和静态属性
2.静态方法不能直接调用类中的其他普通方法和普通属性
普通方法：
随意
一般使用static设置类方法，不用创建对象就能用。这种方法都是工具性质的
一般配合final声明常量值
final关键字
最终关键
类: final类不能被其他类继承
属性：final属性和final变量的值设定后不能更改
方法：final方法不能被子类重写
常量的声明
普通常量
public static final int X = 5;
数组常量
public static final int[] A = {1,2,3};
数组本身不能更改
但是数组中的元素可以重新赋值
单例模式
异常的分类
错误：硬件问题 硬件损坏，网络掉线...
异常：程序逻辑问题 Exception
运行时异常：编译不显示错误，执行时才会发生 RuntimeException
检查性异常：强制在编译时处理异常
异常的处理
throw 在某行人为抛出一个异常对象
throw new Exception();
throws
方法上表示该方法抛出哪些异常需要被使用者处理
public void haha() throws ParseException, IOException{
throw new ParseException(); //检查性异常
throw new IOException(); //检查性异常
}
//强制处理
try{
haha();
}catch(ParseException p){
}catch(IOException e){
}
try...catch...finally
try...catch...finally...
try...catch...
try...catch...catch... 顺序 小catch在大catch
try...finally...
main(){
try{
haha();
sysout("1")
}catch(Exception e){
sysout("2")
}finally{
sysout("3")
}
sysout("4");
}
public void haha(){
int x = 5/3;
}
结果：134
main(){
try{
haha();
sysout("1")
}catch(Exception e){
sysout("2")
}finally{
sysout("3")
}
sysout("4");
}
public void haha(){
int x = 5/0;
}
结果: 234
20180108 练习-下午.txt 没有三角形
有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和。
分子：斐波拉切数列
分母：前一个数的分子
1.Object类: 类的默认父类
equals()方法
Object的equals方法相等于== ==比较的是两个对象的内存地址
String的equals方法重写了Object的equals方法 比较的是内容
String str1 = "abc";
String str2 = "abc";
str1 == str2 ? true
str1.equals(str2) ? true
String str3 = new String("abc");
str1 == str3 ? false
toString()方法
2.字符串类
字符串常量 String final类：不能被其他类继承
字符串变量
StringBuffer 线程安全
StringBuilder 线程不安全
它们三者的区别
3.日期类
java.util.Date
java.sql.Date
Calendar
三者是如何创建并实例化的
创建当前时间的Date
创建特定时间的Date
java.util.Date -> java.sql.Date
字符串与日期之间的类型转换
SimpleDateFormat类 yyyy-MM-dd HH:mm:ss
4.Math类
四舍五入操作round()，小数截取操作ceil(),floor()等等
生成随机数 Math.random() [0,1)随机浮点数
Random类的用法
5.包装类
包装类的作用：某些场合不能使用基本数据类型，使用包装类代替基本数据类型
8个基本数据类型包装类 byte-Byte
int-Integer char-Character
场合：泛型
字符串与基本数据类型的转换
int i = Integer.parseInt("35");
double d = Double.parseDouble("3.14");
String s = 35+"";
6.集合
集合的分类
线性集合 Collection接口 --- List接口
--- ArrayList类
--- LinkedList类
--- Vector类
--- Set接口
--- HashSet类
--- TreeSet类
键值集合 Map接口
-- HashMap类
-- HashTable类
-- TreeMap类
(1)集合的分类有哪些？(常见)
线性集合和键值集合
线性集合有氛围List和Set
(2)线性集合和键值集合的区别？(常见)
从集合的存储结构来说明
(3)List与Set的区别？(常见)
List：有序（序号）可重复
Set：无序不重复
(4)List与Map的区别？(少见)
参照(2)回答，加上List自身的特点
(5)ArrayList与LinkedList的区别？(重要)
本质：数组与链表的区别
(6)ArrayList与Vector的区别?(少见)
ArrayList是线程不安全
Vector是线程安全
(7)HashMap与HashTable的区别?(少见)
HashMap是线程不安全
HashTable是线程安全
Iterator迭代器
迭代器在内存中的运作方式：List和Set都可以通过迭代器进行迭代访问
next()方法
集合的初始化长度
集合没有装满时，就会扩容（集合的底层实现，永远是没有装满的）
集合的具体应用
掌握集合的各个API方法
7.文件与流
包 java.io包
文件类： File类 文件自身的属性，不操作内容
getName(); 得到文件名 字符串截取的方式可以得到文件的扩展名
getPath(); 得到文件的完整路径
文件夹
exists(); 判断路径是否存在
mkdirs(); 创建目录
delete(); 删除目录
文件
exists(); 判断文件是否存在
createNewFile(); 创建文件
delete(); 删除文件
流类：
流向：输入 输出 针对的是内存
单位：字节 字符 文本文档操作内容--字符流 其余都是字节流
功能：原始 处理 处理流中修饰的是原始流
具体的API应用
序列化 特殊的处理流 ObjectInputStream和ObjectOutputStream
将对象序列化至其他介质中实现java.io.Serializable接口
系统中的类大部分都实现了序列化接口：String，包装类，日期类，集合类....
transient关键字：修饰属性，表示该属性不参与序列化过程
8.多线程
Java中线程的实现方式？
继承java.lang.Thread类，并重写它的run方法
实现java.lang.Runnable接口 并实现它的run方法
Java中的线程启动方式？
继承java.lang.Thread类
xxx.start();
实现java.lang.Runnable接口
Thread t = new Thread(xxx);
t.start();
线程的生命周期
参照图片理解
----------------------------------------
sleep与wait的区别
sleep是线程休眠：不会释放CPU的占用权，占用着CPU睡觉
wait是线程等待： 会释放CPU的占用权
9.Socket套接字
理解套接字就是用于连接两台计算机的端口
ServerSocket
Socket
的主要API
10.JDBC
JDBC的步骤
加载驱动
数据库基本信息：连接字符串，用户名和密码
获取数据库连接
创建SQL语句
创建预加载Statement加载SQL
绑定变量
执行SQL
查询：得到结果集并遍历
DML：得到影响了数据库中的行数
关闭连接
Statement与PreparedStatement的区别
Statement加载SQL不安全，执行效率略低
PreparedStatement是预加载的程序，使用？进行参数绑定避免了SQL注入，在数据库服务器提升执行效率
JDBC的主要API
