封装
隐藏对象的属性和实现细节，仅对外提供公共访问方式
提高了代码的复用性
提高了安全性
private
仅仅是封装的一种体现形式，不能说封装就是私有
this
代表当前对象的引用
构造方法
构造方法不能用对象调用
有return;
构造方法的重载
重载：方法名相同，与返回值类型无关（构造方法没有返回值），只看参数列表
static:
非静态方法在调用的时候必须创建对象调用
在主方法中调用本类 的静态方法，可以省略类名，系统会默认加类名
静态只能访问静态
局部代码块
在方法中，限定变量生命周期，及早释放，提高内存利用率
构造代码块（初始化块）
在类中方法出现
每次调用构造都执行，并在构造方法前执行
静态代码块
随类的执行而执行
只执行一次
优先于主方法执行
继承extends
让类与类之间产生关系
父子类的关系
Class Animal{
String color;
Int leg;
String name;
Public void eat(){
System.out.println(“吃饭”)；
}
public void sleep(){
Systrm.out.println(“睡觉”);
}
}
Class Cat extends Animal{}
Class Dog extends Animal{}
提高了代码的复用性
增强了代码的维护性
增强了耦合性
开发的原则：高内聚，低耦合
Java类只支持单继承
Java可以多重继承
子类只能继承父类所有非私有的成员（成员方法和成员变量）
子类不能继承父类的构造方法，但是可以通过super关键字去访问父类构造方法
不要为了部分功能而去继承
Is a的关系
子父类出现同名变量（开发中不会出现）：就近原则，子类有就不用父类的
子类继承父类就是为了使用父类成员
this调用本类的（本类没有，调用父类的）
super调用父类的
子类继承父类
class Son extends Father{
public Son(){
//this和super只能存在一个，且必须在第一条语句
//super();//隐藏了一个super();调用父类无参构造
this(“王五”,25);//调用本类的有参构造
System.out.println(“son 空参构造”);
}
public Son(String name,int age){
super();//也隐藏了一个super();//如果没有无参构造，通过super(name,age);调用父类有参
System.out.println(“son 有参构造”);
}
}
1.jvm调用了man方法，main进栈
2.遇到Zi z = new Zi();会先将Fu.class和zi.class分别加载进内存，当zi.class加载进内存，子类的静态代码会随着zi.class一起加载
3.走子类的构造方法，因为Java是分层初始化的，先初始化父类，再初始化子类，所以先走的父类构造，但是在执行父类构造是，发现父类有构造代码块，构造代码块是优先于构造方法执行的，所以第三个输出构造代码块Fu，第四个输出构造方法Fu
4.Fu类初始化结束，子类初始化，第五个输出构造代码块zi,再走构造方法zi
静态代码块-->构造代码块-->构造方法
继承中成员方法的关系
class Father{
Public void print(){
Public .out.println(“Fu print”);
}
}
class Son extends Fu{
public void method(){
Public.out.println(“Zi print”);
}
Public void print(){ //重写
Super.print(); //调用父类的print();
Public .out.println(“Zi print”);
}
}
重写
子父类出现了一模一样的方法
当子类需要父类的功能，而功能主体子类有自己特有的内容，可以重写父类的方法
class Ios7{
public void call(){
System.out.println(“打电话”);
}
Public void siri(){
Systrm.out.println(“speak English”);
}
}
class Ios8 extends Ios7{
Public void siri(){
System.out.println(“说中文”);
super.siri();//可以不在第一行，可以不写不调用父类方法
}
}
1.父类的私有方法不能被重写
2.子类重写父类方法是，访问权限不能更低
子类的权限必须大于等于父类
为了比父类更强大
- 父类静态方法，子类也必须通过静态方法进行重写
- 子类重写父类方法的时候，最好声明一模一样。
重写override 重载overload
重载可以改变返回值类型，只看参数列表，，，本类中方法名一样，参数列表不同的方法，与返回值类型无关
重写是子类出现了和父类方法声明一模一样的方法，与返回类型有关，返回值是一致的
子类对象调用方法的时候：先找子类本身，再找父类（就近原则）
final 最终
修饰类，类不能被继承 final class fu{}
修饰变量，变量就变成了常量，只能被赋值一次 public static final int NUM= 10;//常量命名规范，大写，一般会与public static共用
修饰方法，方法不能被重写 public final void print(){}
final修饰变量的初始化时机：显示初始化，在对象构造完毕前（在构造方法进行赋值）
成员变量的默认初始化值为无效值，
final修饰基本类型是，值不能被改变
修饰引用类型时，地址值不能被改变，对象中的属性可以改变
重点
面向对象：多态polymorphic
事物存在的多种形态
多态前提：
要有继承关系
要有方法重写
要有父类引用指向子类对象Animal a=new Cat(); a.eat();//调用子类方法
Class Animal{
public void eat(){
System.out.println(“动物吃饭”);
}
}
Class Cat extends Animal{ //有继承关系
Public void eat(){ //有方法重用
System.out.println(“猫吃鱼”);
}
}
成员变量
编译看左边（父类），运行看左边（父类）
成员方法（非静态）
编译看左边（父类），运行看右边（子类）动态绑定
Class Demo2_Polymorphic{
Public static void main(String[] args){
Father f = new Son();
System.out.println(f.num); //输出10，这个f时father类型的
Son s = new Son();
System.out println(s.num); //输出20，
}
}
Class Father{
int num = 10;
}
Class Son extends Father{
Int num = 20;
}
Class Demo3_Polymorphic{
Public static void main(String[] args){
Father f = new Son();
F.print(); //输出son
}
}
Class Father{
int num = 10;
Public void print(){
System.out.print(“father”);
}
}
Class Son extends Father{
Int num = 20;
Public void print(){
System.out.print(“Son”);
}
}
静态方法：编译看左边（父类），运行看左边（父类）
静态和类相关，算不上重写，所以访问还是左边
静态和类相关，不算重写，所以访问还是看左边
Class Demo2_Polymorphic{
Public static void main(String[] args){
Father f = new Son();
F.method() //输出father static method//相当于时Father.method()
}
}
Class Father{
int num = 10;
public void print(){
System.out.print(“father”);
}
public static void method(){
System.out.print(“father static method”);
}
}
Class Son extends Father{
Int num = 20;
Public void print(){
System.out.print(“Son”);
}
public static void method(){
System.out.print(“son static method”);
}
}
基本数据类经自动类型提升和强制类型转换
Int i=10;
Byte b = 20;
I=b; //自动类型提升
B= (byte)i; //强制类型转换
class Demo3_SuperMan{
Public static void main(String[] args){
Person p = new SuperMan(); //父类引用指向子类对象，超人提升为了人
//父类引用指向子类对象就是向上转型
System.out.println(p.name); //结果：John
P.谈生意(); //结果：谈几个亿的大单子
SuperMan sm = (SuperMan)p; //向下转型
sm.fly(); //结果：飞出去救人
}
}
class Person{
String name=”John”;
Public void 谈生意(){
System.out println(“谈生意”);
}
}
class SuperMan extends Person{
String name = “SuperMan”;
public void 谈生意() {
System.out.println(“谈几个亿的大单子”);
}
public void fly() {
System.out.println(“飞出去救人”);
}
}
多态的好处和弊端
弊端：不能使用子类特有的属性和行为
好处：提高了代码的维护性（继承保证）
提高了代码的扩展性（有多态保证）
可以当作形式参数，可以接收任意子类对象
class Demo4_Animal {
Public static void main(String[] args) {
method(new Cat());
method(new Dog());
//Animal a = new Cat();//开发很少用父类引用指向子类，直接创建子类对象可以调用子类方法
}
/*public static void method(Cat c) {
c.eat();
}
public static void method(Dog d) {
d.eat();
}*/ //扩展性太低
//正确
//如果把狗强转成猫，会有ClassCastException异常
Public static void method(Animal a){ //当作参数的时候用多态最好，扩展性强
//关键字instanseof判断前面的引用是否是后边的数据类型
If(a instanceof Cat) {
Cat c = (Cat)a;
c.eat();
c.catchMose();
}else if(a instanceof Dog){
Dog d=(Dog)a;
d.eat();
d.lookHome();
}else{
}
}
}
class Animal{
Public void eat(){
System.out.println(“动物吃饭”);
}
}
Class Cat extends Animal{
Public void eat(){
System.out.println(“猫吃鱼”);
}
Public void catchMouse(){
System.out.println(“捉老鼠”);
}
}
Class dog extends Animal{
Public void eat(){
System.out.println(“狗吃肉”);
}
Public void lookHome(){
System.out.println(“狗看家”);
}
}
抽象类
抽象类不一定有抽象方法，有抽象方法的类一定是抽象类或者是接口
抽象类是按照多态的方式，由具体的子类实例化，抽象类多态
抽象类的子类，要么是抽象类
要么重写抽象类中的所有抽象方法
abstract class Animal{ //抽象类
public abstract void eat(); //抽象方法，直接加分号，不加大括号
}
//abstract class Cat extends Animal{}//抽象类的子类可以是抽象类
class Cat extends Animal{
public void eat(){ //重写抽象类中的所有抽象方法
System.out.println(“猫吃鱼”);
}
}
抽象类的成员特点
成员变量：既可以是变量，也可以是常量，abstract不能修饰成员变量
有构造方法：给子类进行初始化
既可以是抽象的，也可以是非抽象的
抽象方法：强制要求子类做的事情
非抽象方法：子类继承的事情，提高代码的复用性
abstract class Animal{ //抽象类
private String name;
private int age;
public Animal() {}
public Animal(String name ,int age) {
this.name = name;
this.age = age;
}
public abstract void eat(); //抽象方法，直接加分号，不加大括号
}
class Cat extends Animal{
public void eat(){ //重写抽象类中的所有抽象方法
System.out.println(“猫吃鱼”);
}
}
class Cat extends Animal{
public cat() {}
public cat(String name,int age) {
Super(name,age); //super传给父类进行初始化
}
public void eat(){ //重写抽象类中的所有抽象方法
System.out.println(“猫吃鱼”);
}
Public void catchMose() {
System.out.println(“抓老鼠”);
}
}
class Dog extends Animal{
public Dog() {}
public Dog(String name,int age) {
Super(name,age); //super传给父类进行初始化
}
public void eat(){ //重写抽象类中的所有抽象方法
System.out.println(“狗吃肉”);
}
Public void lookHome() {
System.out.println(“看家”);
}
}
Class Test1_Animal{
Public static void main(String[] args){
Cat c = new Cat(“加菲”，8); //直接创建猫对象
System.out.println(c.getName()+“...”+c.getAge());
c.eat();
c.catchMose();
Dog d = new Dog(“八公”,30);
System.out.println(d.getName()+”...”+d.getAge());
d.eat();
d.lookHome();
}
}
抽象类中可以没有抽象方法，不让它类创建本类对象，交给子类完成
abstract不能和什么关键字共存
abstract和static：
被abstract修饰的方法没有方法体
被static修饰的可以用类名.调用，但类名.调用抽象方法是没有意义的
abstract和final:
被abstract修饰的方法强制子类重写
被final修饰的方法不让子类重写
abstract和private：
被abstract修饰的是为了让子类看到并强制重写
被private修饰的不让子类访问，所以他们是矛盾的
接口：interface
interface 接口名()
class 类名 implements 接口名{}
接口不能被实例化
用多态的方式实例化
接口的子类可以是抽象类
也可以是具体类，要重写接口中的所有抽象方法
interface Inter { //接口
public abstract void print(); //接口中的方法都是抽象的
}
Class Demo implements Inter {
Public void print() { //接口实例化
System.out.print(“print”);
}
}
class Demo1_interface{
//Inter i = new Inter(); //接口不能被实例化
Inter i = new Demo(); //父类引用指向子类对象
i.print();
}
接口的成员特点
interface Inter{ //接口中没构造方法
//接口中定义的成员变量只能是常量，并且是静态的，公共的
Int num = 10; //默认修饰符：public static final
//public void print(){} //接口中不能定义抽象方法
}
Class Demo /*extends Object*/ implements Inter{ //一个类不写继承任何类，默认继承Object类
Public void print() {
System.out.print(num);
}
}
Class Demo2_Interface{
public static void main(String[] args){
Demo d = new Demo();
d.print(); //10
}
}
类与类
继承关系，单继承，可以多层继承
类与接口：
实现关系，可以单实现，也可以多实现
还可以一个类同时实现多个接口
接口与接口：
继承关系，可以单继承，也可以多继承
interface InterA{
public abstract void printA();
}
interface InterB{
public abstract void printB();
}
interface InterC extends InterB,InterA{ //继承关系，可以单继承，也可以多继承
public abstract void printC();
}
//Class Demo implements InterA,implements InterB { //非法
Class Demo implements InterA,InterB {
public void printA(){
System.out.println(“printA”);
}
public void printB(){
System.out.println(“printB”);
}
}
抽象类与接口
抽象类：is a,定义的是该继承体系的共性功能
成员变量：可以是变量，可以是常量
构造方法：有
成员方法：可以抽象，也可以非抽象
接口：like a,定义的是该体系的扩展功能
成员变量：只可以是常量
成员方法：只可以是抽象的
abstract class Animal{
private String name;
private int age;
public Animal(){}
public Animal(String name,int age){
this.name=name;
this.age=age;
}
public abstract class eat();
public abstract class sleep();
}
interface Jumping{
public abstract void jump();
}
class cat extends Animal{
public Cat(){}
public Cat(String name,int age){
Super(name,age);
}
Public void eat() {
System.out.println(“猫吃鱼”);
}
Public void sleep() {
System.out/println(“侧睡”);
}
}
Class JumpCat extends Cat implements Jumping {
public JumpCat(){}
public JumpCat(String name,int age){
Super(name,age); //通过父类传到Cat类，再通过Cat类传到Animal();
}
Public void jump(){
System.out.println(“猫跳高”);
}
}
Class Test1_Animal {
Public static void main (String[] args) {
Cat c= new Cat(“加菲”,8);
c.eat();
c.sleep();
JumpCat jc = new JumpCat(“跳高猫”,3);
jc.eat();
jc.sleep();
jc.jump();
}
}
private<默认<protected<public
private仅本类可访问
默认 仅本类和同一包下的子类或无关类可访问
protected 不同包下的无关类不可范文
public 权限最高
类：
权限修饰符：默认修饰符，public
状态：final
抽象：acstract
成员变量：
权限修饰符：private,默认，protected,public
状态:static,final
构造方法：private,默认,protected,public
成员方法：private,默认,protected,public
static,final
sbstract
组合规则：public static final
成员方法：public static
public abstract
public final
内部类：可直接访问外部类的成员，包括私有
Class Demo1_InnerClass{
Out.Inner oi = new Outer().new Inner();//使用外部类名.内部类名 = 外部类对象.内部类对象
Oi.method();
}
class Outer{
class Inner{
Public void method(){
System.out.println(“Hello world”)
}
}
}
静态成员内部类调用方法：
//外部类名.内部类名 对象名= 外部类名.内部类对象；
Outer.Inner oi = new Outer.Inner();
Class Outer{
Public int num = 10;
Class Inner {
Public int num = 20;
Public void show(){
Int num = 30;
System.out.println(num);//30
System.out.println(this.num);//20
System.out.println(Outer.this.num);10
}
}
}
匿名内部类要写在方法里
继承该类或实现该类的的子类匿名对象
interface Inter {
public void print();
}
Class Outer{
Class Inner implements Inter {
Public void print(){
System.out.println(“print”);
}
}
public void method() {
new Inter () { //实现Inter接口
Public void print(){ //重写抽象方法
System.out.println(“print”);
}
}.print()；
}
}
实现多个方法调用
interface Inter {
public void show1();
public void show2();
}
Class Outer{
public void method() {
/*方法一：
new Inter () { //实现Inter接口
public void show1(){ //重写抽象方法
System.out.println(“show1”);
}
public void show2(){ //重写抽象方法
System.out.println(“show2”);
}
}.show1()；//调用show1()方法
new Inter () { //实现Inter接口
public void show1(){ //重写抽象方法
System.out.println(“show1”);
}
public void show2(){ //重写抽象方法
System.out.println(“show2”);
}
}.show2()；//调用show2()方法
*/
Inter i = new Inter(){
public void show1(){ //重写抽象方法
System.out.println(“show1”);
}
public void show2(){ //重写抽象方法
System.out.println(“show2”);
}
};
i.show1();
i.show2();
//无法调Inter特有方法
}
}
类名调用方法：Outer.method().show
说明method() 是静态的
1-100d 随机数：
Int number = (int)(Math.random()*100)+1
静态优先于对象
重写只允许返回值是子父类关系
Eclipse内容快捷键
Alt+/:
快捷键：
jar是多个class文件的压缩包
API
Application Programming Interface
应用程序编程接口
Object类层次结构的根类，所有类都直接或间接继承这个类
HashCode()地址值
toString():左边：类名
中间：@
右边：16进制的哈希地址值
byte[] getBytes():把字符串转换为字节数组
char[] toCharArray():把字符串转换为字符数组
static String valueOf(char[] chs):把字符数组转换成字符串
static String valueOf(int i):把int类型的数据转换成字符串
String toLowerCase():把字符串转换成小写
String toUpperCase():把字符串转换成大写
String concat(String str):把字符串拼接
StringBuffer：线程安全的可变字符序列，效率低
String:不可变的字符序列，效率高
冒泡排序
两个相邻位置比较，如果前面的元素比后面的元素大就换位置
选择排序
用一个索引位置上的元素，依次与其他索引位置上的元素比较，小的在前，大的在后
package t0702;
public class Test {
public static void main(String[] args) {
int[] arr = {24,69,80,57,13};
bubbleSort(arr);
//selectSort(arr);
print(arr);
}
/*
* 冒泡排序
* 返回值类型，void
* 参数列表，int[] arr
*/
public static void bubbleSort(int[] arr) {
for(int i = 0;i<arr.length-1;i++) {//外循环只要比较arr.length-1次
for(int j = 0;j <arr.length-1;j++){//-1是为了防止索引越界
if(arr[j]>arr[j+1]){
/*
* int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
*/
swap(arr,j,j+1);
}
}
}
}
public static void print(int[] arr){
for(int i = 0;i<arr.length;i++){
System.out.println(arr[i]+" ");
}
}
/*
* 选择排序
* 返回值类型void
* 参数列表int[] arr
*/
public static void selectSort(int[] arr){
for(int i = 0;i<arr.length-1;i++){
for(int j = i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
/*
* int temp = arr[i];
arr[i]=arr[j];
arr[j] = temp;
*/
swap(arr,i,j);
}
}
}
}
/*
* 换位操作
* 返回值类型，void
* 参数列表int[],arr.int i,int j
* 如果某个方法，只针对本类，不想让其它类使用就可以定义为私有的
*/
private static void swap(int[] arr,int i,int j){
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
二分查找：有序的
查找元素对应的索引
package t0702;
public class Test {
public static void main(String[] args) {
int[] arr = {11,22,33,44,55,66};
System.out.println(getIndex(arr,55));
}
/*
* 二分查找
* 返回值类型,void
* 参数列表int[] arr,int value
*/
public static int getIndex(int[] arr,int value) {
int min = 0;
int max = arr.length - 1;
int mid = (min+max)/2;
while(arr[mid] != value){
if(arr[mid]<value){ //中间值小于要找的值
min = mid+1;//最小的索引改变
}else if(arr[mid]>value){ //中间值大于要找的值
max = min-1; //最大索引改变
}
mid = (min+max) / 2; //无论是最大的改变，还是最小的改变，中间值都会改变
if(min>max) {
return -1;
}
}
return mid;
}
}
Arrays:
package t0702;
import java.util.Arrays;
public class Test {
public static void main(String[] args) {
int[] arr={33,22,11,44,66,55};
System.out.println(Arrays.toString(arr)); //数组转字符
Arrays.sort(arr); //排序
System.out.println(Arrays.toString(arr));
int[] arr2={11,22,33,44,55,66};
System.out.println(Arrays.binarySearch(arr, 22));
System.out.println(Arrays.binarySearch(arr, 66));
System.out.println(Arrays.binarySearch(arr, 88));//-7 负的插入点减1
}
}
转二进制：
Integer.toBinaryString(60)//111100
转8进制：
Integer.toOctalString(60)//74
转16进制：
Integer.toHexString(60)//3c
int ---String 四种方法转化
int i = 100;
String s1= i+"";//1 推荐
String s2 = String.valueOf(i);//2 推荐
Integer i2 = new Integer(i);
String s3 = i2.toString();//3
String s4 = Integer.toString(i);//4
System.out.println(s1);
String---int
String s = "200";
Integer i3 = new Integer(s);//将Integer转换成int数
int i4 = i3.intValue();
int i5 = Integer.parseInt(s);//将String转换成int
基本类型包装类有8中，其中其中都有parseXxx的方法，可以将这七种字符串表现形式转换成基本数据类型（除char,,,字符串到子父的转换通过toCharArray()把字符串转换为字符数组）
Integer i1 = new Integer(97);
Integer i2 = new Integer(97);
I1==i2//false,两个对象，肯定是false
I1.equals(i2);//true,比较属性值
Integer i5=127;
Integer i6=127;
I5==i6;//true
I5.equals(i6);//true
Integer i7=128;
Integer i8=128;
I7==i8;//false
I7.equals(i8);//true
-128到127是byte的取值范围，如果在这个取值范围内，自动装箱就不会新创建对象，而是从常量池中获取
如果超过了byte取值范围就会再创建对象,就为false
utilbao下的
类Date某一瞬间，精确到毫秒
Sun Jun 06 13:31:06 CST 2088
东8区
日期与字符串相互转换：
DateFormat df1 = DateFormat.getDateInstance();//相当于父类引用指向子类对象，右边的方法返回一个子类对象
规定日期格式
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy/MM/dd HH:mm:ss”);
System.out.println(sdf.format(d));
将时间字符串换成日期对象
String str=”2000年08月08日 08：08：08”；
SimpleDateFormat sdf = new SimpleDateFormat(“yyyy年MM月dd日 HH:mm:ss”);
Date d = sdf.parse(str);//抛出异常throws ParseException(ctrl+e)
System.out.println(d);
活了多少天
Calender c = Calender.getInstance();//父类引用指向子类对象
System.out.println(c.get(Calendar.YEAR));//2018
System.out.println(c.get(Calendar.MONTH));//6,,通过字段获取月，但月是从0开始编号的
System.out.println(c.get(Calendar.DAY_OF_MONTH));//3
System.out.println(c.get(Calendar.DAY_OF_WEEK));//3,,,周日是第一天
对星期存储中进行查表
public static String getWeek(int week) {
String[] arr = {“”,”星期日”,”星期一”,”星期二”,”星期三”,”星期四”,”星期五”,”星期六”};
return arr[week];
}
c.add(Calendar.YEAR,-1);// 2017/7/3,对指定字段进行加减
c.set(Calendar.YEAR,2000); //修改制定字段
判断闰年：
数组和集合
数组既可以存储基本数据类型，又可以存储引用数据类型（基本数据类型存储的是值，引用数组类型存储的是地址值）
集合只能存储引用数据类型（对象），也可以存储基本数据类型，在存储是会自动装箱变成对象100----new Integer(100)
数组的长度是固定的，不能自动增长
集合的长度是可变的，根据元素的增加而增加
元素个数是固定的---用数组
不固定---用集合
Collection：
object[] arr = c.toArray();//集合转化为数组
for(int i = 0;i<arr.length;i++){
System.out.println(arr[i]);
}
Collection c = new ArrayList();
c.add(new Student(“张三”,23));
c.add(new Student(“李四”,24));
c.add(new Student(“王五”,23));
c.add(new Student(“赵六”,26));
Object[] arr = c.toArray(); //将集合转换成数组
for(int i = 0;i < arr.length;i++) {
Student s = (Student)arr[i]; //向下转型
System.out.println(s.getName()+”...”+s.getAge());
}
带All的方法
boolean addAll(Collection c)
boolean removeAll(Collection c)
boolean containsAll(Collection c)
boolean retainAll(Collection c)
IndexOutofBoundsException:索引越界异常
当存储是使用不存在的索引时，就出现索引越界异常
删除的时候不会自动装箱
List list = new ArrayList();
list.add(111);
list.add(222);
list.add(333);
list.remove(111);//错误，删除的时候不会自动装箱，把111当索引了
数组：
查询快，修改快
增删慢
链表：
查询慢，修改慢
增删快
Vector和ArrayList的区别（底层都是数组）
Vector是线程安全的，效率低
ArrayList是线程不安全的，效率高
ArrayList和LinkedList的区别（都是线程不安全的）
ArrayList底层是数组结果，查询和修改快
LinkedList底层是链表结构的，增和删比较快，查询和修改比较慢
8，9，10，11，12了解 16能看懂
ArrayList newList = new ArrayList<>();
Iterator it = list.iterator(); //根据传入的数据获取迭代器
//去掉集合中的重复数据
while(it.hasNext()){ //遍历老集合
Object obj = it.next();
if(!newList.contains(obj)) {
newList.add(obj);
}
}
重写equals方法，
public boolean equals(Object obj){
Person p = (Person)obj;
return this.name.equals(p.name) && this.age == p.age;
}
栈先进后出
队列先进先出
list:
addLast(obj);
removeLast();
isEmpty();
泛型
Collection<E>---泛型<引用数据类型>
提高了安全性
省去了强转的麻烦
classCastException 当试图将对象强制转化为不是实例的子类时，抛出该异常
泛型不要定义成Object
泛型方法
public<T> 返回类型 方法名()(泛型类型 变量名)
静态方法必须要自己声明自己的类型
数组转集合不能增加或减少元素，但是可以用集合的思想操作数组，也就是说可以使用其他集合中的方法
增强for循环不可以删除
HashSet底层是HashMap
HashSet是单列的，HashMap是双列的
HashSet中数据结构对元素起作用，HashMap中数据结构只对键起作用
HashMap
增加：
Map<String,Integer> map = new HashMap();
Integer i1= map.put(“张三”,”23”);
Integer i2= map.put(“李四”,”24”);
Integer i3= map.put(“王五”,”23”);
Integer i4= map.put(“赵六”,”26”);
Integer i5= map.put(“张三”,”26”);
System.out.println(map);//[赵六=26,张三=23,李四=24,王五=23]
System.out.println(i1);//null,返回被覆盖的值
Integer i5= map.put(“张三”,”26”);//23
删除：
Map<String,Integer> map = new HashMap();
map.put(“张三”,”23”);
map.put(“李四”,”24”);
map.put(“王五”,”23”);
map.put(“赵六”,”26”);
Integer value = map.remove(“张三”);//根据键删除，返回值
System.out.println(value);//23
System.out.println(map);//[赵六=26,李四=24,王五=23]
System.out.println(map.containsKey(“张三”));//判断是否包含传入的键 true or false
System.out.println(map.containsValue(23));//判断是否包含传入的值 true or false
Collection<Integer> c = map.values();
System.out.println(c);//[26,23,24,23]，所有值的集合
map集合不能直接迭代
迭代器遍历
Set<String> keySet = map.keySet();//获取所有键的集合
Iterator<String> it = keySet.iterator();//获取迭代器
while(it.hasNext()){ //判断集合中是否有元素
String key = it.next();
Integer value = map.get(key);//根据键获取值
System.out.println(key+“=”+value)
}
增强for循环遍历
for(String key:map.keySet()){
System.out.println(key+”=”+map.get(key));
}
//Map.Entry说明Entry是Map的内部接口，将键喝值封装成了Entry对象，并存储在Set集合中
Set<Map.entry<String,Integer>> entrySet = map.entrySet();
Iterator<Map.Entry<>String,Integer>> it = entrySet.iterator();
for(MAp.Entry<String,Integer> en : Map.entrySet() {
System.out.println(en.getKey()+”=”+en.getValue());
}
LinkedHashMap:
在Student类中实现comparable<Student>,重写compareT(Student o);方法，根据年龄排序
按姓名比 较
HashMap和Hashtable的区别
共同点：底层都是哈希算法，都是双列集合
区别：
1,HAshMap是线程不安全的，效率高，JDK1.2版本的
Hashtable是线程安全的，效率低
- HashMap可以存储null键和null值
Hashtable不可以存储null键和null值
集合总结：
单列：
双列：
异常：
RuntimeException运行时异常:
NullPointerException:空指针异常：赋值为null还要对它进行访问
IndexOutOfBoundsException:索引越界异常
ArrayIndexoutOfBoudsException:数组
StringIndexOutOfBoundsException：字符串
ClassCastException:类型转换异常
ArithmeticException(“/ by zero”);违背数学运算法则，例如，除数为零
除RuntimeException以外都是编译时的错误
try/catch
try：用来检测异常的，
catch:用来捕获异常
finally:释放资源
try...catch
try...catch...finally
try finally
编译时异常：在编译某个程序的时候，有时会出现异常，比如文件找不到了，这样的异常必须在编译的时候处理，如果不处理就编译不通过
运行时异常：程序员犯的错误，可以处理，也可以不处理
jvm默认用e.printStackTrace();处理异常
thows
主方法抛给jvm:
throw和throws区别
thows表示抛出异常
throw跟的时异常对象
finally控制的语句体一定会被执行、用于释放资源
try {
} catch(Exception e) {
...
return;//就算这里有return也会在执行完finally再彻底返回
} finally {
}
final,finlly,finalize，，，只是长得像
final:
final可以修饰类，不能被继承
修饰方法，不能被重写，
修饰变量，只能被赋值一次
finlly:是try语句中的一个语句体，不能单独使用，用来释放资源
finalize:当垃圾回收器确定不存在对该对象的更多引用时，有对象的垃圾回收器调用此 方法
如果catch里面有return语句，请问finally的代码还会执行嘛？如果会，请问时在return前还是return后
异常注意事项：
1.子类重写父类方法时，子类方法必须抛出相同的异常或父类异常的子类
2.如果父类抛出多个异常，子类重写父类时，只能抛出相同的异常或者时它的子集，子类不能抛出父类没有的异常
3.如果被重写的方法没有异常抛出，那么子类的方法绝对不可以抛出异常，只能try,不能throws.
4.如果该功能内部可以将问题处理，用try，如果处理不了，交给调用者处理，这是throws
区别:
后续程序需要继续运行就try
后续程序不需要继续运行就throws
如果jdk没有提供对应的异常，需要自定义异常