java基础知识复习
2017-04-20 19:50
239 查看
一、java简介
1、java是一门程序设计语言
自然语言
（程序设计语言）
机器语言
2、java历史
1）1990年，年底，Sun公司 启动了一个项目组（Green）--组长 java之父 詹姆斯.高斯林，计划写一门跨平台的语言.
2)1992年, Oak语言诞生。
3）1994年 Oak改名 java , Internet兴起，两个主机之间可以相互传东西。，在互联网的冲击下，被业界认可。
4）1995年5月23日，SUN 公司正式发布了java 1.0
5) 2009年 4月20日，SUN公司被 ORACLE 收购，市值74亿
3、JAVA语言的特点。
1）跨平台性（跨服务器，跨操作系统，跨数据库。。。）
2)简单性 PK C++ 、
3）纯面向对象 （使用计算机来模拟现实世界，解决现实问题）
4）开发性
5）开发成本相对较低
4.java语言的运行机制
程序运行机制：
编译器：源文件 --》机器码文件
（C语言中，a.c --->a.exe）
解释器：源文件--》进行逐行翻译并且运行
（效率不高，具有跨平台性。）
java的运行机制:
先编译，后解释 运行。
源文件（.java）--->编译器---->字节码文件（.class）--->JVM--->解释器--->CPU运行
5.名词解释
JVM（java virtual mechine） 通过软件在不同的操作系统模拟相同的运行环境，
JRE（java runtime environment）java 运行环境 JVM和解释器
JDK(java development kit) java 开发工具 编译器+JRE+工具+类库
二、搭建开发环境
1.安装JDK（根据系统的版本不同，安装32位或者64位）
注意：安装目录不允许出现中文。
2。配置环境变量
位置：计算机右键--》点击 属性--》高级系统设置--》环境变量
JAVA_HOME :JDK安装目录
PATH:JDK安装目录/bin
CLASSPATH:类路径 （. 当前目录）
三、简单的DOS命令
进入doc: cmd 快捷键：win+r
清屏：cls
更换盘符： 如更换D盘 d:
查看盘符/文件夹下的内容：dir
进入文件夹：cd 文件夹名
返回上一级文件夹： cd..
停止操作：ctrl+c
退出：exit
四、第一个完整的java程序
1.创建.java源文件 扩展名（*.java）
2.写代码
任务：在dos中显示一行字符 "Hello World";
3.将java源文件（.java）---》字节码文件（.class）
编译：
编译命令：javac 源文件名.java
4.运行代码
解释：
解释命令：java 类名（不加.class）
注意：
1）public class 类名：代表的是公开类
源文件的名字必须和公开类的名字相同，一个源文件中只能有一个公开类。
2） class 类名：非公开类
允许类名与源文件名不同，一个源文件中可以有多个非公开类
3)先编译后解释运行
编译命令：javac 源文件名.java
解释命令：java 类名（不加.class）
===================================================================
五、包（ package ）:指定源文件编译后的.class文件保存在对应的文件夹下。
1.语法:
package 包名; 放在源文件的有效代码的第一行。
例子：package p1;
package p1.p2;
2.带包编译：
语法：javac -d . XX.java
3.带包运行
语法：java 包名1.包名2...类名
注意事项：
1个源文件中，最多只能有一个package，必须放在第一行。
六、注释：一段描述性文字，增加了代码的可读性，不参与编译过程。
1.单行注释
//红军好帅
2.多行注释
/*这是一个主函数，他的功能是，打印一个分隔符
这是一个主函数，他的功能是，打印一个分隔符
这是一个主函数，他的功能是，打印一个分隔符
这是一个主函数，他的功能是，打印一个分隔符
*/
3.文档注释
/**
javadoc 文档注释
*/
七、变量
1.定义：变量是JVM内存中的一块儿空间，用于保存数据。
1）定义变量（声明变量）
数据类型 变量名；
int a;
int b;
2)赋值
变量名=值;
a=5;
3)声明变量的同时给变量赋值
数据类型 变量名=值;
int b = 6;
4)使用
System.out.println(变量名);
System.out.println(a);
2.数据类型
1）基本类型/简单类型
整数类型：
byte 1B-128~127 byte b=128;//error
short 2B-32768~32767
short s=235;
int 4B-2147483648~2147483647
int i=5;
long 8B-2^63 ~2^63-1
long l=8L;
注意:long类型，一定要在后面加上L或者l.
小数类型：
float 4B单精度
float f=1.5f;
double
8B 双精度
double d=1.5;
注意：float类型，一定要在后面加上F或者f;
字符类型：
char 2B
三种形式： 字符：'a'
数字：unicode编
1eb77
码，97
16进制数：'\u0041'(了解)
转义字符：
'\n' 换行符
'\t' 制表符
'\\'
'\''
布尔类型：
boolean 取值 true 或者 false
2）对象类型/复杂类型
类（class）
数组
String 字符串
值：""
String s1="A";
String s2="AAAAAA";
String s3="中华人民共和国";
注意：字符串可以和其他类型进行拼接，中间用'+'号连接。
3.数据类型之间的转换
1)数据类型的自动提升（从小类型--》大类型）
byte-->short -->int -->long-->float--> double
两个参数参加运算
有一个数为double，则结果自动类型提升double类型。
有一个数为float，则结果自动类型提升float类型。
有一个数为long，则结果自动类型提升long类型。
2)强制类型转换（从大类型-->小类型）
小数据类型 变量名=
(小数据类型)大类型变量;
例子：int i=(int)d;
4、局部变量
1）局部变量的使用范围，在定义它的位置开始，到相对应的代码块结束
2)定义在函数的内部
3)重合范围内，变量名不允许重复
4)必须先赋值，后使用。
八、标识符
java中标识符的命名规则
1.语法：
由数字 ，下划线，字母，$组成。 数字不能开头。
例子： int 4a=5;//error!
int $3s=6;//ture
2.大小写比较敏感
int Public=7;
3.不能使用关键字和保留字
int class=6;//false
4.没有长度限制
int classclassclassclassclassclassclass=5;
5.编程习惯
1）望文生义
//定义一个计数器变量
int count=0;
2)包名：全小写 例如：package pack1;
3)类名：单词首字母大写 例如：TestVarType
4)变量名：驼峰命名法：
//定义一个计数器变量
int countNumberNumebr=0;
九、运算符和表达式
1.算术运算符
+ - * / % ++ --
int a=5;
int b=6;
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println("-------------------");
System.out.println(10/3);//3
System.out.println(a%b);
//先使用a，后+1
a++------->a=a+1;
//先+1，后使用
++a------->a=a+1;
2.赋值运算符
= +=-=
*= /= %=...
int a=5;
int b=6;
a+=b -------->a=a+b;
a-=b -------->a=a-b;
....
3.关系运算符
== > < >= <= != 结果为： boolean
System.out.println(a>b);
System.out.println(a!=b);
System.out.println(a<=b);
4.逻辑运算符
&& 逻辑与只有两边条件都为true,结果为true,若第一个条件为false,后面就不判断（短路运算符）
|| 逻辑或只要有一边条件为true，结果就为true.(短路运算符)
！ 逻辑非对条件取反
5.三目运算符（条件运算符）
条件表达式？表达式1：表达式2
6.位运算符（了解）
& 按位与
| 按位或
^ 异或
~ 取反
<< 左移
>> 右移
7.表达式：
由变量，字面值，运算符 组成的一个式子，通常有一个结果。
int c=a+b;
int c=a+5;
=========================================================================
一、Scanner（扫描仪）
所在包：java.util
1. import(导包)
import 包名1.包名2....类名;//只导入包中的一个类。
import java.util.Scanner;
import 包名1.包名2....*;//导入包中的所有类
import java.util.*;
注意：1） import 位置，放在 package 语句的后面。
2）自动导包 java.lang 包中的内容是自动导入。
2.创建Scanner对象。
Scanner sc=new Scanner(System.in);
3.使用
int i=sc.nextInt();//键盘输入一个整数，存放在变量i中
二、分支结构
1.基本结构
if(布尔条件){
//代码块
}
先判断布尔条件是否为true,如果为true,就会执行其后代码块中的语句。
if(布尔条件){
//代码块1
}else{
//代码块2
}
先判断布尔条件是否为true,如果为true,就执行代码块1中的内容，如果false，就执行代码块2.
2、多重if
if(布尔条件1){
}else if(布尔条件2){
}else if(布尔条件3){
}else{
}
多条件互斥，哪个条件成立，就执行其后代码块
3.嵌套if
if(布尔条件){
//代码1
if(布尔条件){
//代码2
}
//代码3
}
4. switch 语句
多分支，进行单值比较
switch(表达式){
case 值1：代码块1;
case 值2: 代码块2;
...
default:代码块N;
}
注意：1)当匹配到某个值时，其后的代码块会被执行，但并不能退出整个switch，而是必须 break;来退出！
2)switch后面的表达式，必须是byte/short /int /char 类型（jdk 7.0 支持String 类型）
3)case 后的值，不允许重复。
4）default没有先后 顺序，通常放最后。
====================================================================================
循环结构
定义：重复且有规律的做一件事。
三要素：循环初值 循环结束条件循环递增量
一、 while 循环
语法： while(布尔表达式){
//循环体语句
}
//if(){}
当布尔表达式为true的时候，就会执行循环体语句。
执行完循环体语句之后，再次判断布尔表达式是否为true.
如果为false 退出循环。
二、 do...while 循环
语法： do{
//循环体语句
}while(布尔表达式);
先执行循环体语句，然后再去判断布尔表达式是否为true,
如果为true,就再次执行循环体语句，再去判断布尔表达式，
如果为false ,退出循环。
三、 for 循环
语法： for(初值;循环结束条件;循环递增量){
//循环体语句
}
先赋初值，判断循环结束条件，如果为true,则执行循环体语句，执行完后，执行循环递增量，
又要判断循环结束条件，如果此时不满足条件，退出循环，如果满足，继续执行循环体语句。
小结：
1. while 先判断，后执行0-多次
do...while 先执行，后判断1-多次
2. for ,知道循环执行多少次的情况。
while /do ..while 循环次数未知的情况下，使用
四、循环控制语句
break;//跳出整个循环，可以跳出死循环。
continue;//跳出本次循环
五、循环嵌套
for(){
//循环体语句1
for(){
//循环体语句2
}
//循环体语句3
}
1.打印99乘法表
1*1=1
1*2=2 2*2=4
2.打印三角形
*
***
*****
*******
======================================================================
目前代码中存在的问题？
1.所有的代码写在main函数中，使得代码的行数过多，降低了代码的可读性。
2.代码的冗余过多
函数：
实现特定功能的代码段（块）
注意：1）定义的位置，类以内，其它函数的外面。
2）在一个类中，可以定义多个函数，无先后顺序
一、函数的定义：
1，三要素。
public static void main(String[] args){
}
public static 返回值类型 函数名称 (形式参数列表){//函数声明（签名）
//函数体语句（实现部分）
}
2.返回值类型
1)void，代表该函数没有返回值
2)有返回值
返回值类型:可以是 8种基本类型，也可以是对象类型。
如果返回值是8种基本类型或对象类型类型的话，代表有返回值，意味着函数体语句，要有 return xxx;
xxx的结果类型，必须和返回值类型相同。
3.函数名称
1）有效的标识符
2）望文生义
3）驼峰命名法( helloWorldNiHao )
4.形式参数
形参列表，语法（数据类型1 变量名1,数据类型2 变量名2...）
注意：形参列表中的变量，相当于局部变量，在函数内部有效。
二、函数的调用
调用位置：在函数的内部调用。
1.语法
函数名称(实参列表);
2.实参
实际参数列表,语法：(值1,值2...)
3.使用返回值
如果是void ,不能参与运算或者赋值，或者输出。
如果是8种基本类型或对象类型类型的话。可以对函数进行 运算或者赋值，或者输出
4.执行流程
进入主函数，顺序执行
1）找到函数定义位置
2）实参给形参赋值
3）顺序执行函数体语句
4）返回函数调用的位置
5）顺序执行之前的函数
三、函数的递归调用
在一个函数内部，调用了该函数自己。
注意：避免无穷递归调用。
================================================
一、数组（对象类型/引用类型）
定义：代表一块儿连续的内存空间，用于存储和管理相同类型的多个数据。
注意：连续 相同类型
数组的长度是固定的。
二、数组的定义
1.声明数组
数据类型[] 变量名;
数据类型 变量名[];--不常用
1)声明和创建分开
int[] array;//声明了一个int类型，名字为array的数组
array=new int[5];
2)声明和创建和在一起
int[] array=new int[5];
3)显示初始化的创建
int[] array={1,5,4,7,2};
4）声明创建数组并显示初始化
int[] array=new int[]{1,5,4,7,2};
注意：
1）显示初始化，必须声明和赋值，一起进行。
2）声明创建数组并显示初始化这种形式，new int[]{1,5,4,7,2}，中括号中不允许写任何东西。
2.默认值
数组开辟内存空间后，数组元素中默认有的值。
数值类型： 0 / 0.0
布尔类型： false
char 类型: ''空字符 '\u0000'
对象类型：null 例如：String[]
二、数组的使用
下标： 0 到 数组的长度-1
获取数组的长度
array.length;
赋值： a[下标]=值;
注意：
java.lang.ArrayIndexOutOfBoundsException: 5
数组下标越界 异常。
数组的遍历(访问数组中多有的元素)：
for(int i=0;i<=a.length-1;i++){}
数组的引用：通过地址找到数组中的值。
三、数组的扩容
1.方法一，大搬家--把海鹏老师放到冰箱里
2.方法二，System.arraycopy(原数组,原数组的起始下标,新数组,新数组的起始下标,要复制的长度);
3.方法三，java.util.Arrays.copyOf(原数组,新长度);
===========================================================================
四、数组的排序
1.冒泡排序
原则：每相邻的2个数比较大小，小的往前放，大的往后放（从小到大的顺序）
2.选择排序
原则：固定下标的数，和其后面的所有数依次进行比较，小的往前放，大的往后放（从小到大的顺序）
五、二维数组
定义：一维数组的数组
1，数组的声明
数据类型[][] 变量名;
int[][] a; //声明了一个二维数组
a=new int[4][3];//第一个中括号控制行，第二个控制列
int[][] a=new int[5][4];
int[][] a={
{1,3,4},
{6,3,7},
{1,2,3}
};
int[][] a=new int[][]{{1,3,4},{6,3,7},{1,2,3}};
注意：
1）显示初始化。必须和变量的声明放在一起
2）new int[][]{{1,3,4},{6,3,7},{1,2,3}};这种形式的中括号中不允许写任何数字
2.遍历
双下标
a[0][0];代表 第1行，第一列的值
a.length
二维数组的行数
a[i].length
二维数组的列数
======================================================================
一、编程思想
需求-----》建立思路（分析）-----》目标代码
面向过程的思想：从过程入手，自顶向下，逐步求精
面向对象的思想：从对象入手，把解决问题所需要的对象准备好，通过对象之间的配合完成需求。
二、什么是面向对象
1.什么是对象
万物皆对象，一切客观存在的事物都是对象。
属性：有什么
方法：做什么
大对象，可以由小对象组成
对象的方法，可以由自己来使用，也可以被其他对象所使用。
2.面向对象
从对象入手，把涉及到的所有对象找到，借助于对象和对象之间的相互配合，实现任务。
3.计算机中的对象
内存中的一块儿空间
是现实对象在计算机中的抽象表示。
4.面向对象的好处
各司其职 对象应该保持简单性
弱耦合性 对象和对象之间的联系应该尽量弱化
可重用性
可扩展性
5.类的概念
1）类 是客观对象在人脑中的主管反映
2）类 是对象共性的抽象
3）类 是对象的模板
对象 是类的一个具体体现。
三、类的组成(重点)
1.属性（实例变量/全局变量）
数据类型 变量名;
**************局部变量 和 实例变量 的区别*********************
局部变量 实例变量
定义的位置 函数内部 类以内，方法以外
作用范围 从定义的位置开始，到定义的代码块结束至少是本类有效
默认值 先赋值后使用有默认值（跟数组一样）
命名冲突 重合范围内避免命名冲突实例变量可以和局部变量发生命名冲突
2.方法（函数）
访问修饰符 返回值类型 方法名（形参列表）{
//方法体
}
方法的重载:在一个类中，可以定义多个同名的方法，必须遵守以下的规则：
1）形参列表不同（个数，类型，顺序，任意一个不同）
2）返回值类型是无要求
3)构造方法
是特殊的方法，可以重载
语法要求：1）方法名 必须和类名完全一样。
2）没有返回值类型
（连void 都没有 ）
注意：1）不允许手动调用,由jvm在创建对象的时候自动调用，只调用1次，
2）在一个类中，如果没有构造方法，系统会自动添加一个无参构造方法，public 类名（）{}
3)构造方法的作用;通常用于给属性赋值。
四、创建对象
类和对象的关系：
类 是对象的模板
对象 是类的 实例
类名 变量名=new 类名(构造参数);
GirlFriend gf=new GirlFriend();
GirlFriend gf2=new GirlFriend("小花",18,"女");
使用对象：
使用属性：对象名.属性名
使用方法：对象名.方法名(实参列表);
======================================================================
一.this关键字
1.引用 指向当前对象的 this.
用在构造方法中，this代表当前对象
this.属性 代表了 当前对象的属性
this.方法
代表了 当前对象的方法
注意：区分局部变量 实例变量
不能在static方法中使用
2.this（构造参数）
用在构造方法中 调用本类的其他方法
注意：必须写在第一行 只能有一个This();
二.创建对象的过程
1.分配空间
给所有属性赋值 默认值
2.初始化属性
给所有属性赋值 初始值
3.调用本类的构造方法赋值 给所有属性第三次赋值
三.引用
数据类型：
基本类型：8种
对象类型：数组 String 类
基本类型的变量： 存数值
对象类型的变量： 存地址
java中数据的传递
基本类型： 传值
对象类型： 传地址
==================面向对象的三大特性==================
一、封装
类有一个边界，可以对数据起到保护作用。
属性私有，提供公有的get/set方法
数据隐藏：
1）属性私有 private
private 数据类型 变量名;
2)提供公开的get/set方法
//get方法，获取属性的值
public 数据类型 getXXX(){
return this.XXX;
}
//set方法，设置属性的值
public void setXXX(数据类型 XXX){
this.XXX=XXX;
}
使用：
封装前：
对象名.属性名;
封装后：
对象名.set/get方法
二、继承
类和类之间是一种"is - a"关系，也是"一般-特殊"的关系。
一般的类，被称为父类、超类、基类
特殊的类.被称为子类、扩展类
思想：类与类之间的共性，可以提取出来，定义成父类
使用：子类可以使用父类中已有的方法（可重用性），还可以增加新的功能（可扩展性）
特点：单继承（一个子类中只能有一个直接的父类）
语法：
class 子类名 extends 父类名 {}
思考：子类可以使用父类中的那些内容？
1）构造方法 不能被继承
2）待补充、、、、、、
三、访问修饰符（可见性）
本类 同包不同包的子类
其他
private （私有）
OK
[default]（默认）
OK OK
protected （受保护）OK
Ok OK
public （公开）
OK Ok OkOK
注意：1）以上4个访问修饰符，都可以修饰属性，方法、构造方法
2) 只有public 和默认[default]可以修饰类
四、方法覆盖
覆盖：在子类中，把从父类继承过来的方法，进行重新实现
语法要求：
1）方法名，参数列表，返回值类型 必须相同。
2）访问修饰符 可同或者 更宽。
五、 super
有2中用法
1. super.
用在子类的方法或者构造方法中
代表 直接父类对象
super.属性
使用父类中被覆盖的属性
super.方法
使用父类中被覆盖的方法
2. super(实参)
用在子类的构造方法中。
代表 在创建子类对象时，告诉JVM必须先创建父类对象。
super(实参) 根据参数来选择要调用父类的构造方法。
注意：1）如果构造方法中没有super(实参)，则默认添加一个
2）super(实参)必须放在子类构造方法中有效语句的第一行
3）在一个构造方法中，super(实参)和this(实参)不允许同时存在
六、子类对象的创建过程
1.分配空间（子类+父类）
给属性赋默认值
2，递归的 创建父类对象（重复2-4）
3.初始化本类属性
给本类属性赋初始值
4.调用本类的构造方法
给本类属性第三次赋值
class C{
int m=5;
int n=10;
int k=6;
}
new A(10,20,30);
A ----> B ----> Cm=0 n=0 k=0
1，分配空间(A+B+C)
//步骤1
2. 创建父类对象B
1）创建父类对象C
1-1)创建父类对象（没有）
1-2）初始化属性C
m=5 //步骤2
1-3)调用C的构造方法
m=10 //步骤3
2）初始化属性B的属性
//步骤4
3）调用B的构造方法
//步骤5
3，初始化属性A
//步骤6
4.调用A的构造方法
//步骤7
===================================================================
多态（多种形态）
一、多态
多态：父类的引用可以指向不同子类的对象，而导致父类引用的多种形态。
语法： 父类类名 引用名 = new 子类类名（构造参数）；
父类引用 子类对象
父类类型 子类类型
主观认为类型
客观实际类型
特点：
1）子类对象类型 始终不变
2）编译时，使用父类引用，只能调用父类中声明的方法
3）运行时，如果子类覆盖了父类中的方法，则执行子类中的方法。
二、对象类型 的类型转换
1、子类对象 赋值给 父类引用
Animal an=new Dog();
结论：多态(父类的引用指向子类的对象)
2.父类引用 赋值给 子类引用（大类型 赋值给 小类型）
Animal an=new Dog();
Dog dog=(Dog)an;
结论：父类引用 赋值给子类引用，必须进行强制类型转换（只保证编译OK），
运行时有可能会有问题。java.lang.ClassCastException;
3.不存在继承关系的对象 相互赋值
Person p=new Person();
Dog dog=(Dog)p;
结论：不存在继承关系的对象，不允许相互转换。
三、 instanceof
语法： 引用名 instanceof 类名
an instanceof Dog
判断 引用指向的对象和后面的类型， 是否兼容，兼容是true.
注意：不存在继承关系的对象，不能使用instanceof来判断。
四、多态在开发中的应用。
1.多态应用在方法的参数上。
调用方法时，可以传的参数类型，包括父类和其所有子类对象
2.多态应用在返回值上。
调用方法后，可以得到的结果类型 包括 父类和其所有子类对象
五.多态的好处
对使用者 屏蔽了不同子类间的差异，使得方法的调用更简单、通用。
=================================================================
三大修饰符
访问修饰符:private default protected public
一、 static 静态
1.属性
static 修饰属性，称为 类变量，也叫静态属性。
语法：static 访问修饰符 数据类型 变量名;
特点：类变量，被所有对象共享（与对象无关）
使用：类名.属性名
对象名.属性名//不推荐使用。
2.方法
static修饰的方法，称为类方法，也叫静态方法
语法： 访问修饰符 static 返回值类型 方法名（形参列表）{}
使用：类名.方法名（实参）
对象名.方法名（实参）//不推荐使用。
注意：1） static 方法中，不允许使用 this 和 super
2)static 方法中，只能直接调用其他 static 成员（属性/方法）
不能直接调用其他非静态的成员。
3）static 方法 只能被 static 的方法覆盖。但是没有多态！
4)使用引用 调用被覆盖的static方法，
引用类型 自己的static方法会被执行。
3.初始代码块
初始代码块：定义在类以内，方法以外的代码块
用于创建对象 和 属性初始化时，按照定义的顺序 依次进行 对象的初始化工作
静态初始化代码块：被 static修饰的初始化代码块
用于在类加载 和 初始化static 属性时，按照定义的顺序 依次进行 对象的初始化工作
4.类加载
当jvm 第一次使用某个类，会现在 类路径 下 找到对应的.class文件，
并且对.class文件进行读取，获得其中的类相关的信息（属性/方法/返回值类型/包...）
特别提醒：只进行1次。
类加载的时机：
1）创建对象
2）使用类的 静态属性或方法
3）创建子类对象
二、 final 最终
1.变量（局部变量，实例变量，类变量）
final 修饰的变量，是常量，只能赋值1次，不可修改。
注意：1） final 修饰的实例变量，将不再分配默认值，
可以在声明中对其进行赋值。
可以在构造方法中对final修饰的变量进行赋值，
如果在构造方法中赋值，所有的构造方法都必须进行赋值。
2)final 修饰的类变量，将不会分配默认值。
可以在声明 或者 静态初始化代码块中赋值
2.方法
final修饰的方法，为最终方法，不能覆盖。
3.类
final修饰的类，为最终类，不能被继承。
//如果一个类是final,里面的方法默认也是 final
三、 abstract 抽象
1.方法
抽象方法，只有声明，没有实现
注意：抽象方法，必须放在抽象类中
2.类
abstract 修饰的类，为抽象类。 不能实例化
注意：
1)抽象类，不能创建对象。但是可以声明引用
2）子类 继承抽象类，必须 实现抽象类中的所有方法，除非子类还是一个抽象类
3)抽象类中 既可以有抽象方法，也可以有非抽象的方法。
抽象类的好处：强制使用多态。
四、小结
1.static、final、abstract能否修饰构造方法？
static 不能。static修饰的元素与对象无关。
而构造方法与对象有关，而且用于创建对象。
final 不能。final 修饰的方法不能被覆盖
而构造方法是不能被继承，何谈覆盖。
abstract 不能，abstract 修饰的方法没有实现。
而构造方法是用来创建对象，必须实现。
2.不能一起使用的修饰符
private abstract :
private 修饰的方法不能被继承，如果两个一起用，该方法永远没有实现。
static abstract :
static修饰的方法与对象无关，可以通过类名直接调用，而abstract没有实现。
final abstract :
final 修饰的方法不能被覆盖，而abstract 方法，必须借助子类来实现。
===================================================
一、接口
接口，是特殊的抽象类。
相同点：1）1个接口 编译后， 生成对应的.class文件。
2）不能创建对象，可以声明引用（强制使用多态）
不同点：1）接口中没有构造方法
2）接口中的所有方法都是抽象方法 ，且默认是 public abstract 修饰的，
3）接口中所有的属性都是常量，并且默认是 public static final 修饰的。
二、语法
定义接口： interface 接口名 extends 父接口名1,父接口名2...{}
（ class 类名 extends 父类名{}）
接口和接口之间是多继承，而类与类之间是单继承
实现接口： class 实现类名 implements 父接口1，父接口2...{}
实现类 和 接口 之间是 多实现 关系
注意： 1）实现类实现父接口，必须实现接口中给所有的方法，除非实现类是抽象的。
2)实现类 实现父接口中的方法，修饰符必须是 public
3)对象类型转换，不论是否和某个接口有继承/实现关系，只要强制转换成该接口类型，编译通过。
但是，运行时可能会出现ClassCastException。
如果实现类，既要继承父类又要实现父接口，语法：先继承，后实现
class 实现类名 extends 父类名 implements 父接口..
三、面向对象的关系小结
继承：
类和类 ： 单继承
接口和接口：多继承
实现：
类和接口：多实现。
先继承，后实现
class 实现类名 extends 父类名 implements 父接口..
四、接口的好处
1.多继承
为了多继承，把对象的主要功能（父类）和次要功能（接口）进行区分
2.弱耦合性
接口定义后，接口的使用者 和 实现者 进行分离，借助于多态，降低了类和类之间的耦合性。
=====================================================
内部类
一、定义：定义在类的内部类
编译阶段的概念，编译后，会分别生成对应的.class文件
二、
1. 成员内部类（相当于成员变量位置）
1.1 定义在成员变量位置的类
1.2 创建成员内部类对象
Outer outer = new Outer();
Inner inner = outer.new Inner();
1.3 可以在不破坏封装的前提下，访问外部类的私有成员
1.4 外部类类名.this 指向外部类当前对象
1.5 成员内部类中不能存在类变量 static 修饰的
2. 静态内部类（相当于类变量位置）
2.1 static 修饰的内部类
2.2 创建静态内部类对象
In in = new Out.In();
2.3 静态内部类 是可以拥有 类变量
3. 局部内部类（相当于局部变量的位置）
3.1 定义在局部变量的位置 有效范围从方法的开始 到 方法的结束
3.2 局部内部类访问外部类局部变量的时候 外部类局部变量需要final
4. 匿名内部类（特殊的局部内部类）
4.1 只创建该类的一个对象时
4.2 继承一个父类或实现一个接口
new + 父类的类名或接口名 + （） +{ 类的具体实现 }
紧密耦合关系 ： new 类名（）
强制弱耦合。
Object 类
一、定义： Java中所有类的父类 ，间接父类。
没有明确指定父类，默认继承Object类。
Object o = 任何对象 子类对象是可以放到父类引用当中。
二、方法
1. protected void finalize()
垃圾对象被垃圾回收器回收时自动调用。
垃圾对象：失去引用的对象称之为垃圾对象 零引用算法
何时自动调用：当虚拟机（JVM） 没有新的内存用来创建对象，自动调用finalize();
手动调用：System.gc();
2.Class<?> getClass()
返回对象的实际类型。
3.String toString()
返回字符串(对象的实际内容)
如果我们想打印对象的实际内容需要覆盖其toString方法。
4. boolean equals(Object obj) 判断当前对象（this）和 o 对象是否相同
public boolean equals(Object obj){
//判断自反性
if(this == obj)return true;
//判断是否为空 null
if(obj == null)return false;
//判断是不是同一个类型
if(this.getClass() != obj.getClass()) return false;
//强制类型转换
Teacher1 t1 = (Teacher1) obj;
//对比对象内容是否一致 八种基本类使用 == 对象类型使用 equals
if(this.name.equals(t1.name) && this.age == t1.age){
return true;
}else{
return false;
}
}
包装类
1. 为8种基本类型提供对象形式，让Object类统一所有数据。
int ---Integer
short ---Short
long ---Long
char --- Character
boolean ---Boolean
float ---Float
double
--- Double
byte ---Byte
2. 对象类型 null 基本类型是0 包装类便于我们对0 和 null区分
3. Integer int String 类型之间的相互转换
//int - Integer
int i = 1;
Integer i1 = new Integer(i);
int i2 = i1.intValue();
//int - String
String s = i+ "";
int i3 = Integer.parseInt(s);
//Integer - String
String s1 = i1.toString();
Integer i4 = Integer.valueOf(s1);
4. JDK 5.0以后的新特性
有Java编译器自动完成简单类型 和 包装类之间的转换。
=====================================================
String类
一、概念 String 代表字符串 字符串常量（final），在创建之后不能更改。
创建对象：
String s ="hello"; 创建一个对象，存在串池当中
串池：Java中 池是为了资源的重用。
String s1 = new String("hello");
创建了两个对象，一个在串池当中，另一个在堆空间当中。、
二、方法：
详见Api
三、String 不变性。
对String对象操作时，都是先对原对象进行拷贝，然后在副本的基础上进行操作。
（原对象不会发生任何改变）
四、可变字符串 StringBuffer 和 StringBuilder
StringBuffer JDK 1.0 线程安全 慢
StringBuilder
JDK 1.5 线程不安全
快
======================集合-List【重点】=======================
集合：集合也是一个对象。是一个容器。用于存储和管理 多个其他对象的对象。
一、Collection 接口 (List 和 Set接口的父接口)
1.特点
用于存储任意 Object 对象
2.方法
boolean add(Object obj)//把元素obj添加到集合中，如果返回值为true，说明添加成功。
boolean addAll(Collection c)//把集合c中的所有内容添加到集合中，如果返回值为true，说明添加成功。
...
详见API
3.遍历
详见子接口实现类
4.实现类
无实现类
二、List 接口
1.特点
用于存储任意 Object 对象
元素 有顺序、有下标，元素可以重复。
2.方法
从Collection父接口继承到的所有方法
多了一些与下标有关的方法：
void add(int index, Object obj);//把对象obj添加到集合指定下边index位置
Object get(int index)//根据下边index，获取指定位置的元素
Object remove(int index)//根据下标index删除集合中的对应元素，返回删除的对象。
Object set(int index, Object obj)//根据下边index修改对应的元素obj,返回修改前的对象。
...
3.遍历
1)下标遍历
for(int i=0;i<arrList.size();i++){
Object obj = arrList.get(i);
String name=(String)obj;
System.out.print(name+" ");
}
2）通过迭代器遍历
Iterator:
boolean hasNext()//判断下一个位置是否有元素,有返回true.
Object next()//自动后移一位，然后返回当前迭代的元素
Iterator iter = arrList.iterator();
while(iter.hasNext()){//判断下一个位置是否有元素
Object obj = iter.next();
String name=(String)obj;
System.out.print(name+" ");
}
3）for-each遍历
4.实现类
//鄙视题
1)ArrayList
数组实现 查询快，增删慢
jdk1.2版本
效率高
2)LinkedList
链表实现 查询慢，增删快
jdk1.2版本
3）Vector
数组实现
jdk1.0版本 效率低
泛型集合：类型安全的集合，强制集合元素的类型必须一致。
三、Set接口
1.特点
用于存储 任意Object
无序，无下标，元素不可重复
2.方法
从Collection父接口中继承到的所有方法
3.遍历
1） 迭代器遍历
2） for-each
4.实现类
1)HashSet
为了实现 HashSet中的元素不能重复，必须进行2个步骤
1.覆盖equals（）
比较对象内容是否相同。
2.覆盖hashCode（）
返回的hashCode相同的情况下，才会调用equals进行比较。
2）TreeSet
可以对集合元素自动排序。
==============================Map接口=======================
1.特点
用于存储 任意的 键值对（Key --- Value）
键：无序、无下标、不允许重复(唯一)
值：无序、无下标，允许重复
2.方法
V put(K key, V value)//往map中添加1个键值对，
如果集合中key已经存在，则新的value覆盖旧的value.
V get(Object key)//根据key获取对应的值。
V remove(Object key)//根据key删除map集合中的1个键值对。
boolean containsKey(Object key)//判断map集合中是否包含为key的键
boolean containsValue(Object value) //判断map集合中是否包含为value的值
3.遍历
1)键遍历
Set keySet();
2）值遍历
Collection values();
3）键值对遍历
Set<Map.Entry<K,V>> entrySet()
4.实现类
1） HashMap
如果key为对象类型，保证key唯一。
必须覆盖hashCode()和equals()
jdk 1.2
效率高
key和value 允许是null
2)HashTable
jdk 1.0
效率低
key和value 不允许是null
3）Properties
key 和 value 必须是String
通常用于读取配置文件。
4）TreeMap
实现了 对key 的排序。
================================================
异常:程序运行中出现的错误。
异常处理：异常放生时，回去执行某一段预先写好的代码，以减少用户的损失。
一、异常分类
Throwable父类
|-Error
错误 底层的严重问题 无法避免 程序员管不了，也不管。
|-Exception
异常
|-RuntimeException运行时异常/未检查异常 编译器会忽略，可以避免 可以处理，也可以不处理
|-NullPointerException
|-IndexOutOfBoundsException
|-ClassCastException
|-非RuntimeException 非运行时异常/已检查异常 编译器不会忽略，不可避免，必须处理
二、异常的产生以及传递
1.产生
1）自动产生
程序运行时，遇到出错的代码，自动产生异常，程序自动终止
2）手动产生
throw new 异常类名(实参);//手动抛出异常，必须写在方法以内
程序执行到手动抛异常，把 throw 后面 new 的异常对象抛出，程序自动终止
（实参），可以随意定义。
2.传递
程序因异常终止后，会以 函数调用的反方向进行传递。
异常堆栈信息：
Exception in thread "main" java.lang.RuntimeException: 密码错误！
at com.baizhi.textexception.TestException.m3(TestException.java:26)
at com.baizhi.textexception.TestException.m2(TestException.java:16)
at com.baizhi.textexception.TestException.m1(TestException.java:11)
at com.baizhi.textexception.TestException.main(TestException.java:6)
三、异常的处理
1.消极处理（声明异常）
throws :声明异常。
使用语法：（定义在方法声明的后面）
修饰符 返回值类型 方法名（形参列表） throws 异常类名1,异常类名2... {}
使用 throws 只是消极的把异常传递给上级，并没有解决异常。
2.积极处理（捕获异常）
try{
//可能会出现异常的语句
}catch(异常类名 e){//捕获异常 并且能把捕获到的异常，自动传递给e 对象。
//处理异常的代码
}finally{
//不论有没有异常，总是会被执行到的代码
}
注意：1）try后面可以跟多个 catch ,但是 父类异常必须放在最后
2）catch可以捕获的异常 是 try中可能出现的异常 可以是非运行时，也可以是运行时异常。
3）finally中的代码总会被执行。
4）finally中的 return 总会被执行。
四、方法覆盖
语法要求：
1）方法名、参数列表、返回值类型 必须相同
2）访问修饰符 可同 或 更宽
3）子类中的方法，不允许抛出 更多，更广的异常
=======================线程=========================
一、概念
进程：操作系统中，并发执行的程序。
并发执行的原理：宏观并行，微观串行
线程：在1个 进程 中，并发执行的 多个程序逻辑。
主线程：main函数
线程的组成；
1）CPU 操作系统可以分配时间片
2）内存分配
栈空间 局部变量独立
堆空间 new 对象共享
3）代码
1.继承Thread类
1）自定义一个线程类
class MyThread extends Thread
2)覆盖run()
public void run()
3）创建线程对象
MyThread t1=new MyThread();
4）开启线程
t1.start();
2.实现 Runnable 接口
1）自定义一个目标类
class Target implements Runnable
2）实现run()
public void run()
3）创建目标对象
Target tar=new Target();
4）创建线程对象
new Thread(tar);
5）开启线程
t2.start();
二、线程状态
详见“线程状态图1.png”
三、线程同步
临界资源：多线程并发时，共享一个对象，这个对象就叫做临界资源。
原子操作：作为一个整体，要执行的代码，如果执行的话，都要执行，如果不执行，则都不执行。
线程同步/安全：多线程并发时，为了保证临界资源的正确性，而不破坏代码的原子操作。
1）同步代码块 synchronized
使用在方法内部，语法：
synchronized (临界资源对象){
}
线程 只有或得到 临界资源对象 的锁标记，才能执行{}里面的代码，
并且必须等{}中所有内容执行完毕，才会释放锁标记。
2)同步方法
synchronized 修饰方法
synchronized 返回值类型 方法名（形参）{
//原子操作
}
四、线程间的通信（等待-通知）[了解]
wait()
注意：1）必须使用 在同步代码块中。
2）调用了wait() 就是让线程 处于 等待状态（等待队列）
3）该线程会释放自己获取到的锁标记，同时也会交出CPU
notify()/notifyAll()
注意：1）必须使用在 同步代码块中。
2）一旦获取到CPU，同时获取到该对象的锁标记。
该线程就可以运行
3）通知其他线程 可以从等待队列状态出来，
五、思考
1.ArrayList和Vector 的区别？
ArrayList JDK 1.2效率高 线程不安全
Vector JDK 1.0效率低 线程安全
2.synchronized 能修饰构造方法、抽象方法、static方法吗？
修饰构造方法：不能 。 构造方法执行时，对象尚未初始化
修饰抽象方法：不能 。抽象方法没有实现部分
修饰static方法：能。对 类对象 加锁。
===============================I/O流==================
一、流的概念
流：数据传输的通道、管道。
持久化：把数据 从内存 往其他存储设备 存储的过程。
流的分类：
1）从方向
输入流
输出流
2）从传输的内容
字节流：可以操作 所有类型的文件
字符流：只能操作 文本文件（可以用记事本打开，并且不出现乱码）
3）从功能
节点流：具有 基本的 读写功能
过滤流：在节点流的基础上，增加了新的功能。
二、字节流
InputStream/OutputStream 父类
字节流：FileInputStream/FileOutputStream 文件字节输入流/文件字节输出流
1、FileOutputStream
void write(int b)
1次写一个字节的内容，把字节b的内容 输出到 对应的文件中。
void write(byte[] b)
1次写多个字节的内容，把数组b的所有内容输出到对应的文件中。
void write(byte[] b, int off, int len)
1次写多个字节的内容，把b数组的部分内容（从下标off开始，长度为len）,输出到对应的文件中。
2.FileInputStream
int read()
1次读1个字节，返回读到的字节内容，如果到了结尾,返回-1
int read(byte[] b)
1次读多个字节，返回读到的内容，并且把内容放到b数组中，如果到了结尾，返回-1
int read(byte[] b, int off, int len)
1次读多个字节，把读到的 len 长度的内容放到b数组中（从下标off开始）
并且返回读到的个数，如果到了结尾，返回-1
作业：
复制图片
1.png------>2.png
byte[] b=byte[1024];
==================================== I/0===========================
InputStream/OutputStream 父类
节点流：FileInputStream/FileOutputStream 文件字节输入流/文件字节输出流
过滤流：DateInputStream/DateOutputStream 操作8种基本类型 还可以操作字符串类型。
BufferedInputStream/BufferedOutputStream 并且带一个缓冲功能。
ObjectInputStream/ObjectOutputStream 可以对对象进行读写操作。
对象序列化：把 对象 在内存和 其他存储设备间 进行传输。
注意：对象序列化，必须保证该对象可序列化。
必须 实现 java.io.Serializable 接口
ois.readObject();//读取一个对象。如果出现了java.io.EOFException，说明读到了结尾。
transient 修饰的属性，不参加序列化。
注意：1.如果对象的属性 又是自定义对象，则该对象， 也必序 实现序列化。
2.如果对集合对象进行序列化，必须 保证 这个集合中的所有元素 实现序列化。
1.class Student implements Serializable{
name
age
Address address;
}
2.List<Student> list=new ArrayList();
oos.writeObject(list);
字符流：
一、编码方式
西欧：ISO8859-1
简体中文：GBK GB2312
繁体中文：BIG5
万国码：UTF-8
乱码：编码和解码的字符集不同造成乱码。
解决乱码：编解码方式一致。
二、字符流
父类：Reader/Writer 接口
节点流：FileReader/FileWriter 基本的读写操作
过滤流：BufferedReader/PrintWriter
桥转换流；InputStreamReader/OutputStreamWriter
是 字节流--》字符流 之间转换的桥梁，同时可以设置字符编码集，可以解决乱码问题。
===========================================================
三、File 文件
I/O流：对文件中内容的操作。
File:对文件自身的操作。 如：删除文件，改名...
File对象：代表的文件或者是文件夹
//创建
//删除
//改名
//设置只读属性
//判断文件是否存在
作业：利用文件File找出d盘baizhixueyuan目录下面所有的以.java结尾的文件。
四、单例模式
设计模式: 是经验总结，不限制使用语言。
单例： 只创建一个对象。
五、反射
类的对象：基于定义好的类，创建该类的一个实例对象。
类对象： 类加载的产物
获取类对象（三种方法）：
1）使用类名
Class c1=类名.class;
2)使用静态方法
Class c2=Class.forName("包名.类名");
3)使用类的对象
Teacher t1=new Teacher();
Class c3=t1.getClass();
1、java是一门程序设计语言
自然语言
（程序设计语言）
机器语言
2、java历史
1）1990年，年底，Sun公司 启动了一个项目组（Green）--组长 java之父 詹姆斯.高斯林，计划写一门跨平台的语言.
2)1992年, Oak语言诞生。
3）1994年 Oak改名 java , Internet兴起，两个主机之间可以相互传东西。，在互联网的冲击下，被业界认可。
4）1995年5月23日，SUN 公司正式发布了java 1.0
5) 2009年 4月20日，SUN公司被 ORACLE 收购，市值74亿
3、JAVA语言的特点。
1）跨平台性（跨服务器，跨操作系统，跨数据库。。。）
2)简单性 PK C++ 、
3）纯面向对象 （使用计算机来模拟现实世界，解决现实问题）
4）开发性
5）开发成本相对较低
4.java语言的运行机制
程序运行机制：
编译器：源文件 --》机器码文件
（C语言中，a.c --->a.exe）
解释器：源文件--》进行逐行翻译并且运行
（效率不高，具有跨平台性。）
java的运行机制:
先编译，后解释 运行。
源文件（.java）--->编译器---->字节码文件（.class）--->JVM--->解释器--->CPU运行
5.名词解释
JVM（java virtual mechine） 通过软件在不同的操作系统模拟相同的运行环境，
JRE（java runtime environment）java 运行环境 JVM和解释器
JDK(java development kit) java 开发工具 编译器+JRE+工具+类库
二、搭建开发环境
1.安装JDK（根据系统的版本不同，安装32位或者64位）
注意：安装目录不允许出现中文。
2。配置环境变量
位置：计算机右键--》点击 属性--》高级系统设置--》环境变量
JAVA_HOME :JDK安装目录
PATH:JDK安装目录/bin
CLASSPATH:类路径 （. 当前目录）
三、简单的DOS命令
进入doc: cmd 快捷键：win+r
清屏：cls
更换盘符： 如更换D盘 d:
查看盘符/文件夹下的内容：dir
进入文件夹：cd 文件夹名
返回上一级文件夹： cd..
停止操作：ctrl+c
退出：exit
四、第一个完整的java程序
1.创建.java源文件 扩展名（*.java）
2.写代码
任务：在dos中显示一行字符 "Hello World";
3.将java源文件（.java）---》字节码文件（.class）
编译：
编译命令：javac 源文件名.java
4.运行代码
解释：
解释命令：java 类名（不加.class）
注意：
1）public class 类名：代表的是公开类
源文件的名字必须和公开类的名字相同，一个源文件中只能有一个公开类。
2） class 类名：非公开类
允许类名与源文件名不同，一个源文件中可以有多个非公开类
3)先编译后解释运行
编译命令：javac 源文件名.java
解释命令：java 类名（不加.class）
===================================================================
五、包（ package ）:指定源文件编译后的.class文件保存在对应的文件夹下。
1.语法:
package 包名; 放在源文件的有效代码的第一行。
例子：package p1;
package p1.p2;
2.带包编译：
语法：javac -d . XX.java
3.带包运行
语法：java 包名1.包名2...类名
注意事项：
1个源文件中，最多只能有一个package，必须放在第一行。
六、注释：一段描述性文字，增加了代码的可读性，不参与编译过程。
1.单行注释
//红军好帅
2.多行注释
/*这是一个主函数，他的功能是，打印一个分隔符
这是一个主函数，他的功能是，打印一个分隔符
这是一个主函数，他的功能是，打印一个分隔符
这是一个主函数，他的功能是，打印一个分隔符
*/
3.文档注释
/**
javadoc 文档注释
*/
七、变量
1.定义：变量是JVM内存中的一块儿空间，用于保存数据。
1）定义变量（声明变量）
数据类型 变量名；
int a;
int b;
2)赋值
变量名=值;
a=5;
3)声明变量的同时给变量赋值
数据类型 变量名=值;
int b = 6;
4)使用
System.out.println(变量名);
System.out.println(a);
2.数据类型
1）基本类型/简单类型
整数类型：
byte 1B-128~127 byte b=128;//error
short 2B-32768~32767
short s=235;
int 4B-2147483648~2147483647
int i=5;
long 8B-2^63 ~2^63-1
long l=8L;
注意:long类型，一定要在后面加上L或者l.
小数类型：
float 4B单精度
float f=1.5f;
double
8B 双精度
double d=1.5;
注意：float类型，一定要在后面加上F或者f;
字符类型：
char 2B
三种形式： 字符：'a'
数字：unicode编
1eb77
码，97
16进制数：'\u0041'(了解)
转义字符：
'\n' 换行符
'\t' 制表符
'\\'
'\''
布尔类型：
boolean 取值 true 或者 false
2）对象类型/复杂类型
类（class）
数组
String 字符串
值：""
String s1="A";
String s2="AAAAAA";
String s3="中华人民共和国";
注意：字符串可以和其他类型进行拼接，中间用'+'号连接。
3.数据类型之间的转换
1)数据类型的自动提升（从小类型--》大类型）
byte-->short -->int -->long-->float--> double
两个参数参加运算
有一个数为double，则结果自动类型提升double类型。
有一个数为float，则结果自动类型提升float类型。
有一个数为long，则结果自动类型提升long类型。
2)强制类型转换（从大类型-->小类型）
小数据类型 变量名=
(小数据类型)大类型变量;
例子：int i=(int)d;
4、局部变量
1）局部变量的使用范围，在定义它的位置开始，到相对应的代码块结束
2)定义在函数的内部
3)重合范围内，变量名不允许重复
4)必须先赋值，后使用。
八、标识符
java中标识符的命名规则
1.语法：
由数字 ，下划线，字母，$组成。 数字不能开头。
例子： int 4a=5;//error!
int $3s=6;//ture
2.大小写比较敏感
int Public=7;
3.不能使用关键字和保留字
int class=6;//false
4.没有长度限制
int classclassclassclassclassclassclass=5;
5.编程习惯
1）望文生义
//定义一个计数器变量
int count=0;
2)包名：全小写 例如：package pack1;
3)类名：单词首字母大写 例如：TestVarType
4)变量名：驼峰命名法：
//定义一个计数器变量
int countNumberNumebr=0;
九、运算符和表达式
1.算术运算符
+ - * / % ++ --
int a=5;
int b=6;
System.out.println(a+b);
System.out.println(a-b);
System.out.println(a*b);
System.out.println("-------------------");
System.out.println(10/3);//3
System.out.println(a%b);
//先使用a，后+1
a++------->a=a+1;
//先+1，后使用
++a------->a=a+1;
2.赋值运算符
= +=-=
*= /= %=...
int a=5;
int b=6;
a+=b -------->a=a+b;
a-=b -------->a=a-b;
....
3.关系运算符
== > < >= <= != 结果为： boolean
System.out.println(a>b);
System.out.println(a!=b);
System.out.println(a<=b);
4.逻辑运算符
&& 逻辑与只有两边条件都为true,结果为true,若第一个条件为false,后面就不判断（短路运算符）
|| 逻辑或只要有一边条件为true，结果就为true.(短路运算符)
！ 逻辑非对条件取反
5.三目运算符（条件运算符）
条件表达式？表达式1：表达式2
6.位运算符（了解）
& 按位与
| 按位或
^ 异或
~ 取反
<< 左移
>> 右移
7.表达式：
由变量，字面值，运算符 组成的一个式子，通常有一个结果。
int c=a+b;
int c=a+5;
=========================================================================
一、Scanner（扫描仪）
所在包：java.util
1. import(导包)
import 包名1.包名2....类名;//只导入包中的一个类。
import java.util.Scanner;
import 包名1.包名2....*;//导入包中的所有类
import java.util.*;
注意：1） import 位置，放在 package 语句的后面。
2）自动导包 java.lang 包中的内容是自动导入。
2.创建Scanner对象。
Scanner sc=new Scanner(System.in);
3.使用
int i=sc.nextInt();//键盘输入一个整数，存放在变量i中
二、分支结构
1.基本结构
if(布尔条件){
//代码块
}
先判断布尔条件是否为true,如果为true,就会执行其后代码块中的语句。
if(布尔条件){
//代码块1
}else{
//代码块2
}
先判断布尔条件是否为true,如果为true,就执行代码块1中的内容，如果false，就执行代码块2.
2、多重if
if(布尔条件1){
}else if(布尔条件2){
}else if(布尔条件3){
}else{
}
多条件互斥，哪个条件成立，就执行其后代码块
3.嵌套if
if(布尔条件){
//代码1
if(布尔条件){
//代码2
}
//代码3
}
4. switch 语句
多分支，进行单值比较
switch(表达式){
case 值1：代码块1;
case 值2: 代码块2;
...
default:代码块N;
}
注意：1)当匹配到某个值时，其后的代码块会被执行，但并不能退出整个switch，而是必须 break;来退出！
2)switch后面的表达式，必须是byte/short /int /char 类型（jdk 7.0 支持String 类型）
3)case 后的值，不允许重复。
4）default没有先后 顺序，通常放最后。
====================================================================================
循环结构
定义：重复且有规律的做一件事。
三要素：循环初值 循环结束条件循环递增量
一、 while 循环
语法： while(布尔表达式){
//循环体语句
}
//if(){}
当布尔表达式为true的时候，就会执行循环体语句。
执行完循环体语句之后，再次判断布尔表达式是否为true.
如果为false 退出循环。
二、 do...while 循环
语法： do{
//循环体语句
}while(布尔表达式);
先执行循环体语句，然后再去判断布尔表达式是否为true,
如果为true,就再次执行循环体语句，再去判断布尔表达式，
如果为false ,退出循环。
三、 for 循环
语法： for(初值;循环结束条件;循环递增量){
//循环体语句
}
先赋初值，判断循环结束条件，如果为true,则执行循环体语句，执行完后，执行循环递增量，
又要判断循环结束条件，如果此时不满足条件，退出循环，如果满足，继续执行循环体语句。
小结：
1. while 先判断，后执行0-多次
do...while 先执行，后判断1-多次
2. for ,知道循环执行多少次的情况。
while /do ..while 循环次数未知的情况下，使用
四、循环控制语句
break;//跳出整个循环，可以跳出死循环。
continue;//跳出本次循环
五、循环嵌套
for(){
//循环体语句1
for(){
//循环体语句2
}
//循环体语句3
}
1.打印99乘法表
1*1=1
1*2=2 2*2=4
2.打印三角形
*
***
*****
*******
======================================================================
目前代码中存在的问题？
1.所有的代码写在main函数中，使得代码的行数过多，降低了代码的可读性。
2.代码的冗余过多
函数：
实现特定功能的代码段（块）
注意：1）定义的位置，类以内，其它函数的外面。
2）在一个类中，可以定义多个函数，无先后顺序
一、函数的定义：
1，三要素。
public static void main(String[] args){
}
public static 返回值类型 函数名称 (形式参数列表){//函数声明（签名）
//函数体语句（实现部分）
}
2.返回值类型
1)void，代表该函数没有返回值
2)有返回值
返回值类型:可以是 8种基本类型，也可以是对象类型。
如果返回值是8种基本类型或对象类型类型的话，代表有返回值，意味着函数体语句，要有 return xxx;
xxx的结果类型，必须和返回值类型相同。
3.函数名称
1）有效的标识符
2）望文生义
3）驼峰命名法( helloWorldNiHao )
4.形式参数
形参列表，语法（数据类型1 变量名1,数据类型2 变量名2...）
注意：形参列表中的变量，相当于局部变量，在函数内部有效。
二、函数的调用
调用位置：在函数的内部调用。
1.语法
函数名称(实参列表);
2.实参
实际参数列表,语法：(值1,值2...)
3.使用返回值
如果是void ,不能参与运算或者赋值，或者输出。
如果是8种基本类型或对象类型类型的话。可以对函数进行 运算或者赋值，或者输出
4.执行流程
进入主函数，顺序执行
1）找到函数定义位置
2）实参给形参赋值
3）顺序执行函数体语句
4）返回函数调用的位置
5）顺序执行之前的函数
三、函数的递归调用
在一个函数内部，调用了该函数自己。
注意：避免无穷递归调用。
================================================
一、数组（对象类型/引用类型）
定义：代表一块儿连续的内存空间，用于存储和管理相同类型的多个数据。
注意：连续 相同类型
数组的长度是固定的。
二、数组的定义
1.声明数组
数据类型[] 变量名;
数据类型 变量名[];--不常用
1)声明和创建分开
int[] array;//声明了一个int类型，名字为array的数组
array=new int[5];
2)声明和创建和在一起
int[] array=new int[5];
3)显示初始化的创建
int[] array={1,5,4,7,2};
4）声明创建数组并显示初始化
int[] array=new int[]{1,5,4,7,2};
注意：
1）显示初始化，必须声明和赋值，一起进行。
2）声明创建数组并显示初始化这种形式，new int[]{1,5,4,7,2}，中括号中不允许写任何东西。
2.默认值
数组开辟内存空间后，数组元素中默认有的值。
数值类型： 0 / 0.0
布尔类型： false
char 类型: ''空字符 '\u0000'
对象类型：null 例如：String[]
二、数组的使用
下标： 0 到 数组的长度-1
获取数组的长度
array.length;
赋值： a[下标]=值;
注意：
java.lang.ArrayIndexOutOfBoundsException: 5
数组下标越界 异常。
数组的遍历(访问数组中多有的元素)：
for(int i=0;i<=a.length-1;i++){}
数组的引用：通过地址找到数组中的值。
三、数组的扩容
1.方法一，大搬家--把海鹏老师放到冰箱里
2.方法二，System.arraycopy(原数组,原数组的起始下标,新数组,新数组的起始下标,要复制的长度);
3.方法三，java.util.Arrays.copyOf(原数组,新长度);
===========================================================================
四、数组的排序
1.冒泡排序
原则：每相邻的2个数比较大小，小的往前放，大的往后放（从小到大的顺序）
2.选择排序
原则：固定下标的数，和其后面的所有数依次进行比较，小的往前放，大的往后放（从小到大的顺序）
五、二维数组
定义：一维数组的数组
1，数组的声明
数据类型[][] 变量名;
int[][] a; //声明了一个二维数组
a=new int[4][3];//第一个中括号控制行，第二个控制列
int[][] a=new int[5][4];
int[][] a={
{1,3,4},
{6,3,7},
{1,2,3}
};
int[][] a=new int[][]{{1,3,4},{6,3,7},{1,2,3}};
注意：
1）显示初始化。必须和变量的声明放在一起
2）new int[][]{{1,3,4},{6,3,7},{1,2,3}};这种形式的中括号中不允许写任何数字
2.遍历
双下标
a[0][0];代表 第1行，第一列的值
a.length
二维数组的行数
a[i].length
二维数组的列数
======================================================================
一、编程思想
需求-----》建立思路（分析）-----》目标代码
面向过程的思想：从过程入手，自顶向下，逐步求精
面向对象的思想：从对象入手，把解决问题所需要的对象准备好，通过对象之间的配合完成需求。
二、什么是面向对象
1.什么是对象
万物皆对象，一切客观存在的事物都是对象。
属性：有什么
方法：做什么
大对象，可以由小对象组成
对象的方法，可以由自己来使用，也可以被其他对象所使用。
2.面向对象
从对象入手，把涉及到的所有对象找到，借助于对象和对象之间的相互配合，实现任务。
3.计算机中的对象
内存中的一块儿空间
是现实对象在计算机中的抽象表示。
4.面向对象的好处
各司其职 对象应该保持简单性
弱耦合性 对象和对象之间的联系应该尽量弱化
可重用性
可扩展性
5.类的概念
1）类 是客观对象在人脑中的主管反映
2）类 是对象共性的抽象
3）类 是对象的模板
对象 是类的一个具体体现。
三、类的组成(重点)
1.属性（实例变量/全局变量）
数据类型 变量名;
**************局部变量 和 实例变量 的区别*********************
局部变量 实例变量
定义的位置 函数内部 类以内，方法以外
作用范围 从定义的位置开始，到定义的代码块结束至少是本类有效
默认值 先赋值后使用有默认值（跟数组一样）
命名冲突 重合范围内避免命名冲突实例变量可以和局部变量发生命名冲突
2.方法（函数）
访问修饰符 返回值类型 方法名（形参列表）{
//方法体
}
方法的重载:在一个类中，可以定义多个同名的方法，必须遵守以下的规则：
1）形参列表不同（个数，类型，顺序，任意一个不同）
2）返回值类型是无要求
3)构造方法
是特殊的方法，可以重载
语法要求：1）方法名 必须和类名完全一样。
2）没有返回值类型
（连void 都没有 ）
注意：1）不允许手动调用,由jvm在创建对象的时候自动调用，只调用1次，
2）在一个类中，如果没有构造方法，系统会自动添加一个无参构造方法，public 类名（）{}
3)构造方法的作用;通常用于给属性赋值。
四、创建对象
类和对象的关系：
类 是对象的模板
对象 是类的 实例
类名 变量名=new 类名(构造参数);
GirlFriend gf=new GirlFriend();
GirlFriend gf2=new GirlFriend("小花",18,"女");
使用对象：
使用属性：对象名.属性名
使用方法：对象名.方法名(实参列表);
======================================================================
一.this关键字
1.引用 指向当前对象的 this.
用在构造方法中，this代表当前对象
this.属性 代表了 当前对象的属性
this.方法
代表了 当前对象的方法
注意：区分局部变量 实例变量
不能在static方法中使用
2.this（构造参数）
用在构造方法中 调用本类的其他方法
注意：必须写在第一行 只能有一个This();
二.创建对象的过程
1.分配空间
给所有属性赋值 默认值
2.初始化属性
给所有属性赋值 初始值
3.调用本类的构造方法赋值 给所有属性第三次赋值
三.引用
数据类型：
基本类型：8种
对象类型：数组 String 类
基本类型的变量： 存数值
对象类型的变量： 存地址
java中数据的传递
基本类型： 传值
对象类型： 传地址
==================面向对象的三大特性==================
一、封装
类有一个边界，可以对数据起到保护作用。
属性私有，提供公有的get/set方法
数据隐藏：
1）属性私有 private
private 数据类型 变量名;
2)提供公开的get/set方法
//get方法，获取属性的值
public 数据类型 getXXX(){
return this.XXX;
}
//set方法，设置属性的值
public void setXXX(数据类型 XXX){
this.XXX=XXX;
}
使用：
封装前：
对象名.属性名;
封装后：
对象名.set/get方法
二、继承
类和类之间是一种"is - a"关系，也是"一般-特殊"的关系。
一般的类，被称为父类、超类、基类
特殊的类.被称为子类、扩展类
思想：类与类之间的共性，可以提取出来，定义成父类
使用：子类可以使用父类中已有的方法（可重用性），还可以增加新的功能（可扩展性）
特点：单继承（一个子类中只能有一个直接的父类）
语法：
class 子类名 extends 父类名 {}
思考：子类可以使用父类中的那些内容？
1）构造方法 不能被继承
2）待补充、、、、、、
三、访问修饰符（可见性）
本类 同包不同包的子类
其他
private （私有）
OK
[default]（默认）
OK OK
protected （受保护）OK
Ok OK
public （公开）
OK Ok OkOK
注意：1）以上4个访问修饰符，都可以修饰属性，方法、构造方法
2) 只有public 和默认[default]可以修饰类
四、方法覆盖
覆盖：在子类中，把从父类继承过来的方法，进行重新实现
语法要求：
1）方法名，参数列表，返回值类型 必须相同。
2）访问修饰符 可同或者 更宽。
五、 super
有2中用法
1. super.
用在子类的方法或者构造方法中
代表 直接父类对象
super.属性
使用父类中被覆盖的属性
super.方法
使用父类中被覆盖的方法
2. super(实参)
用在子类的构造方法中。
代表 在创建子类对象时，告诉JVM必须先创建父类对象。
super(实参) 根据参数来选择要调用父类的构造方法。
注意：1）如果构造方法中没有super(实参)，则默认添加一个
2）super(实参)必须放在子类构造方法中有效语句的第一行
3）在一个构造方法中，super(实参)和this(实参)不允许同时存在
六、子类对象的创建过程
1.分配空间（子类+父类）
给属性赋默认值
2，递归的 创建父类对象（重复2-4）
3.初始化本类属性
给本类属性赋初始值
4.调用本类的构造方法
给本类属性第三次赋值
class C{
int m=5;
int n=10;
int k=6;
}
new A(10,20,30);
A ----> B ----> Cm=0 n=0 k=0
1，分配空间(A+B+C)
//步骤1
2. 创建父类对象B
1）创建父类对象C
1-1)创建父类对象（没有）
1-2）初始化属性C
m=5 //步骤2
1-3)调用C的构造方法
m=10 //步骤3
2）初始化属性B的属性
//步骤4
3）调用B的构造方法
//步骤5
3，初始化属性A
//步骤6
4.调用A的构造方法
//步骤7
===================================================================
多态（多种形态）
一、多态
多态：父类的引用可以指向不同子类的对象，而导致父类引用的多种形态。
语法： 父类类名 引用名 = new 子类类名（构造参数）；
父类引用 子类对象
父类类型 子类类型
主观认为类型
客观实际类型
特点：
1）子类对象类型 始终不变
2）编译时，使用父类引用，只能调用父类中声明的方法
3）运行时，如果子类覆盖了父类中的方法，则执行子类中的方法。
二、对象类型 的类型转换
1、子类对象 赋值给 父类引用
Animal an=new Dog();
结论：多态(父类的引用指向子类的对象)
2.父类引用 赋值给 子类引用（大类型 赋值给 小类型）
Animal an=new Dog();
Dog dog=(Dog)an;
结论：父类引用 赋值给子类引用，必须进行强制类型转换（只保证编译OK），
运行时有可能会有问题。java.lang.ClassCastException;
3.不存在继承关系的对象 相互赋值
Person p=new Person();
Dog dog=(Dog)p;
结论：不存在继承关系的对象，不允许相互转换。
三、 instanceof
语法： 引用名 instanceof 类名
an instanceof Dog
判断 引用指向的对象和后面的类型， 是否兼容，兼容是true.
注意：不存在继承关系的对象，不能使用instanceof来判断。
四、多态在开发中的应用。
1.多态应用在方法的参数上。
调用方法时，可以传的参数类型，包括父类和其所有子类对象
2.多态应用在返回值上。
调用方法后，可以得到的结果类型 包括 父类和其所有子类对象
五.多态的好处
对使用者 屏蔽了不同子类间的差异，使得方法的调用更简单、通用。
=================================================================
三大修饰符
访问修饰符:private default protected public
一、 static 静态
1.属性
static 修饰属性，称为 类变量，也叫静态属性。
语法：static 访问修饰符 数据类型 变量名;
特点：类变量，被所有对象共享（与对象无关）
使用：类名.属性名
对象名.属性名//不推荐使用。
2.方法
static修饰的方法，称为类方法，也叫静态方法
语法： 访问修饰符 static 返回值类型 方法名（形参列表）{}
使用：类名.方法名（实参）
对象名.方法名（实参）//不推荐使用。
注意：1） static 方法中，不允许使用 this 和 super
2)static 方法中，只能直接调用其他 static 成员（属性/方法）
不能直接调用其他非静态的成员。
3）static 方法 只能被 static 的方法覆盖。但是没有多态！
4)使用引用 调用被覆盖的static方法，
引用类型 自己的static方法会被执行。
3.初始代码块
初始代码块：定义在类以内，方法以外的代码块
用于创建对象 和 属性初始化时，按照定义的顺序 依次进行 对象的初始化工作
静态初始化代码块：被 static修饰的初始化代码块
用于在类加载 和 初始化static 属性时，按照定义的顺序 依次进行 对象的初始化工作
4.类加载
当jvm 第一次使用某个类，会现在 类路径 下 找到对应的.class文件，
并且对.class文件进行读取，获得其中的类相关的信息（属性/方法/返回值类型/包...）
特别提醒：只进行1次。
类加载的时机：
1）创建对象
2）使用类的 静态属性或方法
3）创建子类对象
二、 final 最终
1.变量（局部变量，实例变量，类变量）
final 修饰的变量，是常量，只能赋值1次，不可修改。
注意：1） final 修饰的实例变量，将不再分配默认值，
可以在声明中对其进行赋值。
可以在构造方法中对final修饰的变量进行赋值，
如果在构造方法中赋值，所有的构造方法都必须进行赋值。
2)final 修饰的类变量，将不会分配默认值。
可以在声明 或者 静态初始化代码块中赋值
2.方法
final修饰的方法，为最终方法，不能覆盖。
3.类
final修饰的类，为最终类，不能被继承。
//如果一个类是final,里面的方法默认也是 final
三、 abstract 抽象
1.方法
抽象方法，只有声明，没有实现
注意：抽象方法，必须放在抽象类中
2.类
abstract 修饰的类，为抽象类。 不能实例化
注意：
1)抽象类，不能创建对象。但是可以声明引用
2）子类 继承抽象类，必须 实现抽象类中的所有方法，除非子类还是一个抽象类
3)抽象类中 既可以有抽象方法，也可以有非抽象的方法。
抽象类的好处：强制使用多态。
四、小结
1.static、final、abstract能否修饰构造方法？
static 不能。static修饰的元素与对象无关。
而构造方法与对象有关，而且用于创建对象。
final 不能。final 修饰的方法不能被覆盖
而构造方法是不能被继承，何谈覆盖。
abstract 不能，abstract 修饰的方法没有实现。
而构造方法是用来创建对象，必须实现。
2.不能一起使用的修饰符
private abstract :
private 修饰的方法不能被继承，如果两个一起用，该方法永远没有实现。
static abstract :
static修饰的方法与对象无关，可以通过类名直接调用，而abstract没有实现。
final abstract :
final 修饰的方法不能被覆盖，而abstract 方法，必须借助子类来实现。
===================================================
一、接口
接口，是特殊的抽象类。
相同点：1）1个接口 编译后， 生成对应的.class文件。
2）不能创建对象，可以声明引用（强制使用多态）
不同点：1）接口中没有构造方法
2）接口中的所有方法都是抽象方法 ，且默认是 public abstract 修饰的，
3）接口中所有的属性都是常量，并且默认是 public static final 修饰的。
二、语法
定义接口： interface 接口名 extends 父接口名1,父接口名2...{}
（ class 类名 extends 父类名{}）
接口和接口之间是多继承，而类与类之间是单继承
实现接口： class 实现类名 implements 父接口1，父接口2...{}
实现类 和 接口 之间是 多实现 关系
注意： 1）实现类实现父接口，必须实现接口中给所有的方法，除非实现类是抽象的。
2)实现类 实现父接口中的方法，修饰符必须是 public
3)对象类型转换，不论是否和某个接口有继承/实现关系，只要强制转换成该接口类型，编译通过。
但是，运行时可能会出现ClassCastException。
如果实现类，既要继承父类又要实现父接口，语法：先继承，后实现
class 实现类名 extends 父类名 implements 父接口..
三、面向对象的关系小结
继承：
类和类 ： 单继承
接口和接口：多继承
实现：
类和接口：多实现。
先继承，后实现
class 实现类名 extends 父类名 implements 父接口..
四、接口的好处
1.多继承
为了多继承，把对象的主要功能（父类）和次要功能（接口）进行区分
2.弱耦合性
接口定义后，接口的使用者 和 实现者 进行分离，借助于多态，降低了类和类之间的耦合性。
=====================================================
内部类
一、定义：定义在类的内部类
编译阶段的概念，编译后，会分别生成对应的.class文件
二、
1. 成员内部类（相当于成员变量位置）
1.1 定义在成员变量位置的类
1.2 创建成员内部类对象
Outer outer = new Outer();
Inner inner = outer.new Inner();
1.3 可以在不破坏封装的前提下，访问外部类的私有成员
1.4 外部类类名.this 指向外部类当前对象
1.5 成员内部类中不能存在类变量 static 修饰的
2. 静态内部类（相当于类变量位置）
2.1 static 修饰的内部类
2.2 创建静态内部类对象
In in = new Out.In();
2.3 静态内部类 是可以拥有 类变量
3. 局部内部类（相当于局部变量的位置）
3.1 定义在局部变量的位置 有效范围从方法的开始 到 方法的结束
3.2 局部内部类访问外部类局部变量的时候 外部类局部变量需要final
4. 匿名内部类（特殊的局部内部类）
4.1 只创建该类的一个对象时
4.2 继承一个父类或实现一个接口
new + 父类的类名或接口名 + （） +{ 类的具体实现 }
紧密耦合关系 ： new 类名（）
强制弱耦合。
Object 类
一、定义： Java中所有类的父类 ，间接父类。
没有明确指定父类，默认继承Object类。
Object o = 任何对象 子类对象是可以放到父类引用当中。
二、方法
1. protected void finalize()
垃圾对象被垃圾回收器回收时自动调用。
垃圾对象：失去引用的对象称之为垃圾对象 零引用算法
何时自动调用：当虚拟机（JVM） 没有新的内存用来创建对象，自动调用finalize();
手动调用：System.gc();
2.Class<?> getClass()
返回对象的实际类型。
3.String toString()
返回字符串(对象的实际内容)
如果我们想打印对象的实际内容需要覆盖其toString方法。
4. boolean equals(Object obj) 判断当前对象（this）和 o 对象是否相同
public boolean equals(Object obj){
//判断自反性
if(this == obj)return true;
//判断是否为空 null
if(obj == null)return false;
//判断是不是同一个类型
if(this.getClass() != obj.getClass()) return false;
//强制类型转换
Teacher1 t1 = (Teacher1) obj;
//对比对象内容是否一致 八种基本类使用 == 对象类型使用 equals
if(this.name.equals(t1.name) && this.age == t1.age){
return true;
}else{
return false;
}
}
包装类
1. 为8种基本类型提供对象形式，让Object类统一所有数据。
int ---Integer
short ---Short
long ---Long
char --- Character
boolean ---Boolean
float ---Float
double
--- Double
byte ---Byte
2. 对象类型 null 基本类型是0 包装类便于我们对0 和 null区分
3. Integer int String 类型之间的相互转换
//int - Integer
int i = 1;
Integer i1 = new Integer(i);
int i2 = i1.intValue();
//int - String
String s = i+ "";
int i3 = Integer.parseInt(s);
//Integer - String
String s1 = i1.toString();
Integer i4 = Integer.valueOf(s1);
4. JDK 5.0以后的新特性
有Java编译器自动完成简单类型 和 包装类之间的转换。
=====================================================
String类
一、概念 String 代表字符串 字符串常量（final），在创建之后不能更改。
创建对象：
String s ="hello"; 创建一个对象，存在串池当中
串池：Java中 池是为了资源的重用。
String s1 = new String("hello");
创建了两个对象，一个在串池当中，另一个在堆空间当中。、
二、方法：
详见Api
三、String 不变性。
对String对象操作时，都是先对原对象进行拷贝，然后在副本的基础上进行操作。
（原对象不会发生任何改变）
四、可变字符串 StringBuffer 和 StringBuilder
StringBuffer JDK 1.0 线程安全 慢
StringBuilder
JDK 1.5 线程不安全
快
======================集合-List【重点】=======================
集合：集合也是一个对象。是一个容器。用于存储和管理 多个其他对象的对象。
一、Collection 接口 (List 和 Set接口的父接口)
1.特点
用于存储任意 Object 对象
2.方法
boolean add(Object obj)//把元素obj添加到集合中，如果返回值为true，说明添加成功。
boolean addAll(Collection c)//把集合c中的所有内容添加到集合中，如果返回值为true，说明添加成功。
...
详见API
3.遍历
详见子接口实现类
4.实现类
无实现类
二、List 接口
1.特点
用于存储任意 Object 对象
元素 有顺序、有下标，元素可以重复。
2.方法
从Collection父接口继承到的所有方法
多了一些与下标有关的方法：
void add(int index, Object obj);//把对象obj添加到集合指定下边index位置
Object get(int index)//根据下边index，获取指定位置的元素
Object remove(int index)//根据下标index删除集合中的对应元素，返回删除的对象。
Object set(int index, Object obj)//根据下边index修改对应的元素obj,返回修改前的对象。
...
3.遍历
1)下标遍历
for(int i=0;i<arrList.size();i++){
Object obj = arrList.get(i);
String name=(String)obj;
System.out.print(name+" ");
}
2）通过迭代器遍历
Iterator:
boolean hasNext()//判断下一个位置是否有元素,有返回true.
Object next()//自动后移一位，然后返回当前迭代的元素
Iterator iter = arrList.iterator();
while(iter.hasNext()){//判断下一个位置是否有元素
Object obj = iter.next();
String name=(String)obj;
System.out.print(name+" ");
}
3）for-each遍历
4.实现类
//鄙视题
1)ArrayList
数组实现 查询快，增删慢
jdk1.2版本
效率高
2)LinkedList
链表实现 查询慢，增删快
jdk1.2版本
3）Vector
数组实现
jdk1.0版本 效率低
泛型集合：类型安全的集合，强制集合元素的类型必须一致。
三、Set接口
1.特点
用于存储 任意Object
无序，无下标，元素不可重复
2.方法
从Collection父接口中继承到的所有方法
3.遍历
1） 迭代器遍历
2） for-each
4.实现类
1)HashSet
为了实现 HashSet中的元素不能重复，必须进行2个步骤
1.覆盖equals（）
比较对象内容是否相同。
2.覆盖hashCode（）
返回的hashCode相同的情况下，才会调用equals进行比较。
2）TreeSet
可以对集合元素自动排序。
==============================Map接口=======================
1.特点
用于存储 任意的 键值对（Key --- Value）
键：无序、无下标、不允许重复(唯一)
值：无序、无下标，允许重复
2.方法
V put(K key, V value)//往map中添加1个键值对，
如果集合中key已经存在，则新的value覆盖旧的value.
V get(Object key)//根据key获取对应的值。
V remove(Object key)//根据key删除map集合中的1个键值对。
boolean containsKey(Object key)//判断map集合中是否包含为key的键
boolean containsValue(Object value) //判断map集合中是否包含为value的值
3.遍历
1)键遍历
Set keySet();
2）值遍历
Collection values();
3）键值对遍历
Set<Map.Entry<K,V>> entrySet()
4.实现类
1） HashMap
如果key为对象类型，保证key唯一。
必须覆盖hashCode()和equals()
jdk 1.2
效率高
key和value 允许是null
2)HashTable
jdk 1.0
效率低
key和value 不允许是null
3）Properties
key 和 value 必须是String
通常用于读取配置文件。
4）TreeMap
实现了 对key 的排序。
================================================
异常:程序运行中出现的错误。
异常处理：异常放生时，回去执行某一段预先写好的代码，以减少用户的损失。
一、异常分类
Throwable父类
|-Error
错误 底层的严重问题 无法避免 程序员管不了，也不管。
|-Exception
异常
|-RuntimeException运行时异常/未检查异常 编译器会忽略，可以避免 可以处理，也可以不处理
|-NullPointerException
|-IndexOutOfBoundsException
|-ClassCastException
|-非RuntimeException 非运行时异常/已检查异常 编译器不会忽略，不可避免，必须处理
二、异常的产生以及传递
1.产生
1）自动产生
程序运行时，遇到出错的代码，自动产生异常，程序自动终止
2）手动产生
throw new 异常类名(实参);//手动抛出异常，必须写在方法以内
程序执行到手动抛异常，把 throw 后面 new 的异常对象抛出，程序自动终止
（实参），可以随意定义。
2.传递
程序因异常终止后，会以 函数调用的反方向进行传递。
异常堆栈信息：
Exception in thread "main" java.lang.RuntimeException: 密码错误！
at com.baizhi.textexception.TestException.m3(TestException.java:26)
at com.baizhi.textexception.TestException.m2(TestException.java:16)
at com.baizhi.textexception.TestException.m1(TestException.java:11)
at com.baizhi.textexception.TestException.main(TestException.java:6)
三、异常的处理
1.消极处理（声明异常）
throws :声明异常。
使用语法：（定义在方法声明的后面）
修饰符 返回值类型 方法名（形参列表） throws 异常类名1,异常类名2... {}
使用 throws 只是消极的把异常传递给上级，并没有解决异常。
2.积极处理（捕获异常）
try{
//可能会出现异常的语句
}catch(异常类名 e){//捕获异常 并且能把捕获到的异常，自动传递给e 对象。
//处理异常的代码
}finally{
//不论有没有异常，总是会被执行到的代码
}
注意：1）try后面可以跟多个 catch ,但是 父类异常必须放在最后
2）catch可以捕获的异常 是 try中可能出现的异常 可以是非运行时，也可以是运行时异常。
3）finally中的代码总会被执行。
4）finally中的 return 总会被执行。
四、方法覆盖
语法要求：
1）方法名、参数列表、返回值类型 必须相同
2）访问修饰符 可同 或 更宽
3）子类中的方法，不允许抛出 更多，更广的异常
=======================线程=========================
一、概念
进程：操作系统中，并发执行的程序。
并发执行的原理：宏观并行，微观串行
线程：在1个 进程 中，并发执行的 多个程序逻辑。
主线程：main函数
线程的组成；
1）CPU 操作系统可以分配时间片
2）内存分配
栈空间 局部变量独立
堆空间 new 对象共享
3）代码
1.继承Thread类
1）自定义一个线程类
class MyThread extends Thread
2)覆盖run()
public void run()
3）创建线程对象
MyThread t1=new MyThread();
4）开启线程
t1.start();
2.实现 Runnable 接口
1）自定义一个目标类
class Target implements Runnable
2）实现run()
public void run()
3）创建目标对象
Target tar=new Target();
4）创建线程对象
new Thread(tar);
5）开启线程
t2.start();
二、线程状态
详见“线程状态图1.png”
三、线程同步
临界资源：多线程并发时，共享一个对象，这个对象就叫做临界资源。
原子操作：作为一个整体，要执行的代码，如果执行的话，都要执行，如果不执行，则都不执行。
线程同步/安全：多线程并发时，为了保证临界资源的正确性，而不破坏代码的原子操作。
1）同步代码块 synchronized
使用在方法内部，语法：
synchronized (临界资源对象){
}
线程 只有或得到 临界资源对象 的锁标记，才能执行{}里面的代码，
并且必须等{}中所有内容执行完毕，才会释放锁标记。
2)同步方法
synchronized 修饰方法
synchronized 返回值类型 方法名（形参）{
//原子操作
}
四、线程间的通信（等待-通知）[了解]
wait()
注意：1）必须使用 在同步代码块中。
2）调用了wait() 就是让线程 处于 等待状态（等待队列）
3）该线程会释放自己获取到的锁标记，同时也会交出CPU
notify()/notifyAll()
注意：1）必须使用在 同步代码块中。
2）一旦获取到CPU，同时获取到该对象的锁标记。
该线程就可以运行
3）通知其他线程 可以从等待队列状态出来，
五、思考
1.ArrayList和Vector 的区别？
ArrayList JDK 1.2效率高 线程不安全
Vector JDK 1.0效率低 线程安全
2.synchronized 能修饰构造方法、抽象方法、static方法吗？
修饰构造方法：不能 。 构造方法执行时，对象尚未初始化
修饰抽象方法：不能 。抽象方法没有实现部分
修饰static方法：能。对 类对象 加锁。
===============================I/O流==================
一、流的概念
流：数据传输的通道、管道。
持久化：把数据 从内存 往其他存储设备 存储的过程。
流的分类：
1）从方向
输入流
输出流
2）从传输的内容
字节流：可以操作 所有类型的文件
字符流：只能操作 文本文件（可以用记事本打开，并且不出现乱码）
3）从功能
节点流：具有 基本的 读写功能
过滤流：在节点流的基础上，增加了新的功能。
二、字节流
InputStream/OutputStream 父类
字节流：FileInputStream/FileOutputStream 文件字节输入流/文件字节输出流
1、FileOutputStream
void write(int b)
1次写一个字节的内容，把字节b的内容 输出到 对应的文件中。
void write(byte[] b)
1次写多个字节的内容，把数组b的所有内容输出到对应的文件中。
void write(byte[] b, int off, int len)
1次写多个字节的内容，把b数组的部分内容（从下标off开始，长度为len）,输出到对应的文件中。
2.FileInputStream
int read()
1次读1个字节，返回读到的字节内容，如果到了结尾,返回-1
int read(byte[] b)
1次读多个字节，返回读到的内容，并且把内容放到b数组中，如果到了结尾，返回-1
int read(byte[] b, int off, int len)
1次读多个字节，把读到的 len 长度的内容放到b数组中（从下标off开始）
并且返回读到的个数，如果到了结尾，返回-1
作业：
复制图片
1.png------>2.png
byte[] b=byte[1024];
==================================== I/0===========================
InputStream/OutputStream 父类
节点流：FileInputStream/FileOutputStream 文件字节输入流/文件字节输出流
过滤流：DateInputStream/DateOutputStream 操作8种基本类型 还可以操作字符串类型。
BufferedInputStream/BufferedOutputStream 并且带一个缓冲功能。
ObjectInputStream/ObjectOutputStream 可以对对象进行读写操作。
对象序列化：把 对象 在内存和 其他存储设备间 进行传输。
注意：对象序列化，必须保证该对象可序列化。
必须 实现 java.io.Serializable 接口
ois.readObject();//读取一个对象。如果出现了java.io.EOFException，说明读到了结尾。
transient 修饰的属性，不参加序列化。
注意：1.如果对象的属性 又是自定义对象，则该对象， 也必序 实现序列化。
2.如果对集合对象进行序列化，必须 保证 这个集合中的所有元素 实现序列化。
1.class Student implements Serializable{
name
age
Address address;
}
2.List<Student> list=new ArrayList();
oos.writeObject(list);
字符流：
一、编码方式
西欧：ISO8859-1
简体中文：GBK GB2312
繁体中文：BIG5
万国码：UTF-8
乱码：编码和解码的字符集不同造成乱码。
解决乱码：编解码方式一致。
二、字符流
父类：Reader/Writer 接口
节点流：FileReader/FileWriter 基本的读写操作
过滤流：BufferedReader/PrintWriter
桥转换流；InputStreamReader/OutputStreamWriter
是 字节流--》字符流 之间转换的桥梁，同时可以设置字符编码集，可以解决乱码问题。
===========================================================
三、File 文件
I/O流：对文件中内容的操作。
File:对文件自身的操作。 如：删除文件，改名...
File对象：代表的文件或者是文件夹
//创建
//删除
//改名
//设置只读属性
//判断文件是否存在
作业：利用文件File找出d盘baizhixueyuan目录下面所有的以.java结尾的文件。
四、单例模式
设计模式: 是经验总结，不限制使用语言。
单例： 只创建一个对象。
五、反射
类的对象：基于定义好的类，创建该类的一个实例对象。
类对象： 类加载的产物
获取类对象（三种方法）：
1）使用类名
Class c1=类名.class;
2)使用静态方法
Class c2=Class.forName("包名.类名");
3)使用类的对象
Teacher t1=new Teacher();
Class c3=t1.getClass();
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- JAVA相关基础知识(复习java,为的就是搞android)
- java 基础知识在复习第一天（1）
- Java复习第六天---EL&JSTL基础知识
- Java基础知识复习（一）
- java基础知识复习总结--增强型for循环
- 黑马程序员---------java 基础知识复习（foreach、Arrays、String、StringBuffer、容器类）
- Java基础知识复习(一)
- JAVA 基础知识复习
- JavaSE复习之一 基础知识：Java的基础语法
- JAVA基础知识复习面试笔试宝典
- 今天复习了一下java的基础知识。
- java基础知识复习总结
- JAVA基础知识复习5
- JAVA 基础知识复习4
- Java基础知识复习
- 既然开始从头复习Java基础知识，好歹来本参考书吧！
- 我的复习---JAVA基础知识
- JAVA基础知识复习2
- java 基础知识回顾(便于复习)
- JAVA基础知识复习3