编译器默认添加的代码
1)每个java代码, 默认添加 import java.lang.*;
2)如果一个类没有定义任何构造方法,系统默认提供 公开 无参构造方法
3)访问属性和方法,如果不写引用,默认为"this."
4)如果一个构造方法的第一行不是super(...),也不是this(...),系统默认为super();
5)接口中的属性默认为public static final 方法默认为public abstract
6)如果一个类没有指定父类,默认继承Object类
==========================================================================
CoreJava
Java 编程语言 平台
移动互联网
Android -- Java
iOS --- OC
云计算 大数据
==========================================================================
Java
简单（和C++）
面向对象
跨平台 可以运行在不同的操作系统中 Windows Unix Linux Mac ...
编译 源文件 <------>编译器 机器码文件 快 不能跨平台
解释 源文件 <------>解释器 逐行翻译 慢 可以跨平台
Java 先编译 后解释
源文件(.java) ------> 字节码文件(.class) ------> 解释运行
javac java
编译器 解释器
虚拟机 JVM 屏蔽底层OS之间的差异
JDK (Java开发工具包 编译器+解释器+JVM+工具+类库 )
设置三个环境变量
Java_Home : 指向JDK安装目录
Path: 指向JDK安装目录/bin
ClassPath: .
javac 源文件名 (带.java) 一个类 --- 一个.class文件
java 类名 (不带.class)
公开类的类名必须和源文件名相同,包括大小写
一个源文件中可以定义多个类,但最多只能定义一个公开类
package 和磁盘上的文件夹对应
javac -d 路径 源文件名 自动按照包结构生成字节码文件
Java程序的结构
package 0-1
import 0-n
class 1-n 公开类只能写一个
编程习惯 可读性
1.注释
// 单行注释
/*
多行注释 不能嵌套
*/
/**
多行注释 配合JavaDoc工具, 生成API帮助文档
*/
2.缩进
同级代码左对齐
每进入一个代码块,缩进一次
每行一句代码
3.标识符规则
字母,数字,_,$ 数字不能开头
没有长度限制
大小写敏感
不能使用关键字和保留字
习惯:
1.望文知义
2.大小写
包名 全小写 helloworld
类名 单词首字母大写 HelloWorld
变量名/方法名 首单词小写,后面单词首字母大写 helloWorld
常量名 全大写 HELLOWORLD
变量
强类型:变量类型和变量中存储数据类型必须一致
定义变量 变量类型 变量名; int a; int a,b;
变量名 = 数据 a=10;
int a = 10;
数据类型
基本数据类型 (原始 简单)
byte 1B -128 -- 127 10 010 0x10 0b10 (since 1.7)
short 2B -32768 -- 32767
int 4B -2147483648 -- 2147483647
long 8B -2^63 - 2^63-1 字面值 加L
float 4B 单精度浮点数 字面值加F
double 8B 双精度浮点数 字面值加D 或者不加 2.8e10
char 2B 字符 'A' 65 '\u0041' 'A' 65 'a' 97 '0' 48
转义字符 \n \t \" \' \\
boolean 字面值 true false
对象类型
String 字符串 字面值 "ABCD"
表达式 值
运算类型: a b 发生运算 (类型提升)
a,b中有double --> double
a,b中有float --> float
a,b中有long --> long
--> int
= a=b
+ - * / %
+= -= *= /= %= (不发生类型提升) a+=b <===> a=a+b
++ -- a++ <===> a+=1
== a==b 判断a和b值是否相同
!=
> < >= <=
&&(逻辑与) ||(逻辑或) !(逻辑非)
(布尔表达式)?值1:值2
局部变量 定义在方法内部的变量
1. 先赋值,再使用
2. 作用范围: 从定义开始,到它所在的代码块结束
3. 重合范围内,不允许2个局部变量重名
=============================================================================
程序执行流程
1.顺序执行流程 语句执行1次
2.条件分支流程 语句执行0-1次
if (布尔表达式) { 代码块 }
if (布尔表达式) { 代码块1 } else { 代码块2 }
if (条件1){}
else if (条件2){}
else if (条件3){}
...
else {}
switch(int表达式) byte short int char String (since 7.0)
{
case 值1:
case 值2:
case 值3:
}
break 跳出switch-case
3.循环流程 语句执行n次
while(布尔表达式){ 代码块 } 0-n次
do{循环体} while(循环条件); 1-n次
for(循环变量初始化 ; 循环条件 ; 循环变量变化) {循环体} 0-n次 确定循环
int i = 0 ; i < n ; i++ n次
int i = 1 ; i <= n ; i++ n次
break : 跳出循环
continue: 跳出本次循环
===============================================================================
函数 独立的过程
可维护性
定义
1.函数的声明 static 返回值类型 函数名 (参数表)
形式参数:形参 函数内部有效的局部变量
2.函数的实现 { }
调用
函数名(参数表)
实际参数:实参 为对应的形参赋值
函数的作用:
1.减少冗余代码, 提高程序的可维护性
2.提高可重用性 函数库
3.提升程序的结构化
非结构化 ----> 结构化 (面向过程)
数组
一次性定义多个同类型的变量
定义数组
int[] a ;
int []a ;
int a[] ;
分配空间 指定长度 数组名.length 表示数组长度
a = new int[5];
默认值:
数值类型:0
布尔类型:false
对象类型:null
int[] a;
a = new int[]{1,3,2,6,5};
a = {1,3,2,6,5}; //error
int[] a = new int[]{1,3,2,6,5}; //显式初始化
int[] a = {1,3,2,6,5};
访问数组元素: 数组名[下标]
a[0] a[1] a[2] a[3] a[4]
数组在内存中存储空间必须是连续的
数组的长度固定!
二维数组
定义 int[][] a;
分配空间 a = new int[3][4];
a = new int[][]{{1,2,3,4},{5,6,7,8},{0,0,0,0}};
冒泡排序: 相邻的元素比较
选择排序: 一个元素和剩余所有元素比较
==================================================================================
面向对象思想
对象:一切客观存在的事物 Object
是什么
有什么 属性
能做什么 方法
is a 继承
has a 关联
use a 依赖
先找到解决问题所需要的对象,再建立对象间的联系和过程
计算机中的对象:内存中一块数据 代表了生活中的对象 抽象
面向对象的优势,要求
各司其职 简单的对象组成复杂的系统
弱耦合性 对象之间的联系尽可能弱化
可重用性
可扩展性
类
对象的抽象,是对象在人脑中的反应 人对对象的认识
对象的模板
类是代码,对象根据类的模板创建出的数据
属性:成员变量
1.有默认值 默认值规则等同于数组默认值规则
数值 0
布尔 false
对象 null
2.作用范围:全类内部
3.可以和局部变量重名,访问时局部变量优先
方法
声明: 修饰符 返回值类型 方法名(参数表) 抛出的异常
对象能做什么
实现: {} 对象怎么做
方法的重载 (Overloading)
多个方法,方法名相同, 参数表不同(参数个数不同,参数类型不同,参数类型排列不同)
如果只有参数名不同,不算重载
由编译器根据实参类型,选择相应的方法调用 (编译时多态)
作用:让一个对象的同类方法,由于参数表的不同所造成的实现差异对用户屏蔽
构造方法
1.没有返回值类型
2.方法名必须和类名相同
3.不能手工调用,对象构造过程中自动调用一次
如果一个类没有定义任何构造方法,系统默认提供 公开 无参构造方法
创建对象: new 类名(构造参数)
简单变量:存数值
引用:存放对象的地址 null 表示该引用没有指向任何对象
方法参数传递规则:
简单类型参数传值,对象类型参数传地址(实参和形参共同指向同一对象)
this:
1. 引用 当前对象
this.
访问属性和方法,如果不写引用,默认为"this."
区分成员变量和局部变量
2. this() 调用本类其他构造方法 必须是构造方法的第一条语句
===============================================================================
三大特性
封装 明确的边界
属性私有 set/get访问方法
方法可以公开,可以私有
继承 一般--特殊 父类 -- 子类 is a
父类的哪些属性和方法能继承给子类? <==> 子类能访问父类的哪些属性和方法?
访问修饰符
private 私有 类的内部访问 不能继承
(default) 默认 本类+同包 同包子类可以继承
protected 受保护的 本类+同包+子类 可以继承
public 公开 可以继承
构造方法不能继承
方法覆盖 (Override)
子类用特殊的方法实现替换掉父类继承给它的方法实现
访问修饰符相同或更宽,返回值类型,方法名,参数表相同
单继承 一个类只能有一个直接父类
类之间会形成简单的树状结构
super
1.引用 父类对象
用来访问父类的属性,或者调用父类被覆盖的方法
2.super() 用在构造方法的第一条语句 表示创建父类对象
如果一个构造方法的第一行不是super(...),也不是this(...),系统默认为super();
对象构造过程
1.分配空间(非静态属性) 属性被赋予默认值
2.创建父类对象
3.初始化本类非静态属性 属性被赋予初始值
4.调用本类构造方法 属性可以被赋予构造参数
A <--- B <--- C
分配空间
初始化A类属性
调用A类构造方法
初始化B类属性
调用B类构造方法
初始化C类属性
调用C类构造方法
多态
子类对象可以赋值给父类引用
1.对象类型不变
2.只能对引用调用引用类型中声明的方法
3.运行时根据对象实际类型,运行子类覆盖之后的方法
子类引用可以直接赋值给父类引用
父类引用需要通过强转,赋值给子类引用
引用 instanceof 类名 判断引用所指向的对象和 类名 是否兼容
是不是 用于强制类型转换之前,避免类型转换异常
a instanceof Dog true
a instanceof Cat false
a instanceof Animal true
多态的作用 通用性
可以把不同的子类对象统一看做父类对象,屏蔽不同子类的差异
多态用在方法的参数上 method(A a):method方法接受A类或A的子类对象作为实参
多态用在方法的返回值上 A method(): method方法返回的是A类或A的子类对象
==================================================================================
修饰符
private 属性 方法 构造方法
(default) 属性 方法 构造方法 类
protected 属性 方法 构造方法
public 属性 方法 构造方法 类
static 静态
1.属性
静态属性全类共有
类名访问
2.方法
类名直接调用
静态方法不能访问类的非静态成员,包括this
对引用调用静态方法,等价于对引用类型调用静态方法
静态方法只能被子类的静态方法覆盖,而且没有多态
3.初始代码块
静态初始代码块 在类加载的时候执行一次
类加载:当JVM第一次使用一个类时,需要找到这个类对应的.class文件,并把这个文件中类的信息读取到JVM中,并保存起来.
类加载的过程:
1)如果需要的话,先加载父类
2)按照定义顺序,初始化静态属性,或执行静态初始代码块
类加载的时机:
1)第一次创建类的对象
2)第一次访问类的静态成员
3)第一次调用Class.forName()
如果只是声明类的引用,不会发生类加载
final
1.变量 常量 一旦赋值,不能改变
final属性没有默认值,必须在初始化属性或构造方法中赋值一次
2.方法 不能被子类覆盖
3.类 不能被子类继承
abstract 抽象的
1.类 抽象类只能声明引用,不能创建对象
半成品 供子类继承
2.方法 抽象方法只有声明,没有实现
如果一个类中包含抽象方法,这个类就必须是抽象类
子类继承抽象类,如果子类不希望也成为抽象类,就必须实现父类中所有的抽象方法
private final static 都不能和abstract同时出现
单例模式
===============================================================================
接口 特殊的抽象类
1.所有的方法都是公开抽象方法 public abstract
2.所有的属性都是公开静态常量 public static final
3.没有构造方法
一个类实现接口,如果这个类不希望成为抽象类,就必须实现接口中所有方法
接口之间可以多继承
一个类在继承另外一个类的同时,还可以实现多个接口
接口的作用:
1.多继承 主要类型-次要类型
用接口实现多继承,不会破坏类之间树状关系的简单性
2.解耦合工具 将接口的实现者和接口的使用者分离
接口回调:接口和接口的使用者预先定义,个人负责接口实现
A ---> I --- B
=================================================================================
内部类
成员内部类
可以访问外部类的私有成员
用"外部类类名.this"访问外部类的当前对象
创建对象:先创建外部类对象,再通过"外部类对象.new 内部类类名()"
静态内部类
只能访问外部类的静态成员
直接用"new 外部类类名.内部类类名()"创建对象
局部内部类
作用范围:从定义开始.到所在代码块结束
不仅可以访问外部类的私有成员,还可以访问外部类的局部常量 (final)
匿名内部类 特殊的局部内部类
1.用于继承某个类或实现某个接口
2.只会创建一个对象
===============================================================================
Object Java中所有类的父类
1. Object o = 任何对象
2. Object类中定义的方法是所有Java对象都具有的方法
getClass(): 获取对象的实际类型
finalize(): 在对象被垃圾回收时,由垃圾收集器自动调用
垃圾对象判定:零引用
垃圾回收时机:延迟回收
toString(): 返回对象的字符串形式
public String toString()
打印对象,就是打印对象toString方法的返回值
equals(): 判断2个对象内容是否相同
public boolean equals(Object o):比较this和o对象的内容
包装类 8种基本类型 --- 包装类
int -- Integer
char -- Character
double -- Double
自动封箱 由编译器自动处理基本类型和包装类之间的转换
============================================================================
String
常见方法:
length():字符串长度
charAt(int pos):获得pos下标的字符
toCharArray():将字符串转为字符数组
String(char[] cs):利用cs数组构造字符串
toUpperCase()转大写
toLowerCase()转小写
indexOf(String s):返回子串s在字符串中出现的首下标
indexOf(String s, int from):返回子串s在字符串中从from下标开始的首下标
startsWith(String s):判断字符串是否以s子串开头
endsWith(String s):判断字符串是否以s子串结尾
trim():去掉字符串前后的空格及换行
replace(String s1,String s2):将字符串中s1子串替换为s2子串
split(String s):将字符串以s为分隔符,切割为字符串数组
substring(int from,int end):获得从from下标到end下标的子串,包含from,不包含end
堆:存放对象
栈:存放局部变量
代码空间:存放共享资源 (静态属性 串池)
intern():返回字符串在串池中的地址
================================================================================
集合 容器
对象 管理,储存多个对象
Collection
基本特点: 元素是Object
常见方法:
add(Object o):将对象o添加到集合中
clear():清空集合
contains(Object o):判断集合中是否包含对象o
remove(Object o) :删除对象o
size():获得集合的长度
toArray():将集合转为数组
遍历:
迭代遍历 for-each
实现类:无
List Collection的子接口
基本特点: 元素是Object 元素有顺序,有下标 可以重复
常见方法:
add(int pos,Object o):将元素o添加到pos下标
remove(int pos):删除pos下标的元素
get(int pos):获得pos下标的元素
indexOf(Object o):获得o在集合中的下标
遍历:
1.下标遍历
2.迭代遍历 for-each
实现类:
1.ArrayList 数组实现 查询快 增删慢 1.2 线程不安全 快
2.LinkedList 链表实现 查询慢 增删快
3.Vector 数组实现 1.0 线程安全 慢
Set Collection的子接口
基本特点: 元素是Object 元素无下标,元素内容不可重复
常见方法: 无
遍历:迭代遍历 for-each
实现类:
HashSet
自定义的对象放入HashSet,为了保证对象内容不重复:
1)覆盖hashCode方法,保证相同对象返回相同的int
尽量保证不同对象返回不同的int
2)覆盖equals方法,保证相同对象比较返回true
LinkedHashSet HashSet的子类 维护元素添加到Set中的顺序
TreeSet SortedSet(Set的子接口)的实现类 自动对元素排序
Map
基本特点:元素是键值对 键:Object 无顺序 内容不重复 值:Object 可以重复
常见方法:
put(K key,V value):将键值对添加到Map中,如果key已经存在,新的value会替换旧的value
get(K key):通过key获得对应的value
size():获得Map中键值对的数量
remove(K key):删除key所对应的键值对
containsKey(Object key) 判断key是否存在
containsValue(Object value) 判断value是否存在
遍历:
keySet():获得Map中所有key的集合 Set
values():获得Map中所有value的集合 Collection
实现类:
HashMap 1.2 线程不安全 允许用null作为key或value
LinkedHashMap HashMap的子类 维护键值对添加到Map中的顺序
TreeMap SortedMap(Map的子接口)的实现类 自动对key排序
Hashtable 1.0 线程安全 不允许用null作为key或value
Properties 1.0 Hashtable的子类 键和值都是String 用于配置文件的读取
泛型 since JDK5.0 模板编程
在集合中,泛型用来约束集合中元素的类型
==================================================================================
异常处理 容错性
try{
插卡
输入密码和金额2000
余额-=2000
吐钱2000元
catch(吐钱异常 e){
余额+=2000
}
finally{
退卡
}
Throwable 异常 错误父类
|-- Error 错误 严重 无法避免 无法处理
|-- Exception 异常 可以处理
|-- RuntimeException 及其子类 未检查异常 可以避免 可处理可不处理
|-- 非RuntimeException 已检查异常 无法避免 必须处理
throw : 抛出一个异常 等同于return语句
异常的处理:
1.声明抛出 throws 声明如果有异常,就向上抛出,由上级方法处理
2.捕获异常 try-catch
try - catch
try - catch - finally finally:无论如何都会执行的代码 往往用于释放资源
try - finally
方法覆盖 (Override)
子类用特殊的方法实现替换掉父类继承给它的方法实现
访问修饰符相同或更宽,返回值类型,方法名,参数表相同,
子类不能比父类抛出更多的异常
-------------------------------------------------------------------------------------------------------------------------------------------------
===============================================================================
I/O 输入/输出
流 用来传输数据的对象
流的方向:输入流/输出流
数据单位:字节流/字符流
流的功能:节点流/过滤流 节点:实际负责传输数据 过滤:为节点流增强功能
1.创建节点流
2.封装过滤流
3.读写数据
4.关闭流
字节流
InputStream/OutputStream 字节流的父类 抽象类
FileInputStream/FileOutputStream 文件字节流 节点流
write(int a):写一个字节
write(byte[] bs):写一个字节数组
write(byte[] bs,int start , int length):写字节数组中的一段
read():读一个字节
read(byte[] bs):读满字节数组 返回值:读入的字节个数
read(byte[] bs,int start,int length):读满字节数组中的一段
DataInputStream/DataOutputStream 读写8种基本类型和String
BufferedInputStream/BufferedOutputStream 缓冲流 提高I/O效率
PrintStream 缓冲输出流 System.out :PrintStream类的对象
ObjectInputStream/ObjectOutputStream 读写8种基本类型,读写Object
对象序列化:利用I/O流传输对象
只有实现了Serializable接口的对象才能序列化
用transient修饰的属性为临时属性,不参与序列化
字符的乱码:编码方式和解码方式不统一
ASCII 美国
ISO8859-1 西欧
GB2312/GBK 简体中文
Big5 繁体
Unicode UTF-8 UTF-16(char类型的编码方式)
字符流
Reader/Writer 字符流的父类 抽象类
FileReader/FileWriter 节点流 读写文件
BufferedReader/BufferedWriter 缓冲流
PrintWriter
InputStreamReader/OutputStreamWriter 桥转换 字节流 --> 字符流
在桥转换时,可以指定编解码方式
JSON : 对象的统一字符串格式 {"name":"suns","age":30,"score":80.0}
Gson.jar Google提供的拼装和解析JSON字符串的API
File 代表磁盘上的文件或目录
exist():判断文件是否存在
createNewFile():创建新文件
mkdir():创建新目录
delete(): 删除文件或空目录
isDirectory():判断File对象代表的是不是目录
isFile():判断File对象代表的是不是文件
listFiles():获得目录中所有内容 返回值:File[]
=======================================================================
视频16
代码消亡的原因不是需求变化，而是不断更改，最后没有逻辑。