基础知识

类作为成员变量类型：

接口作为成员变量类型：

接口作为方法的参数或者返回值

Object类：

java.lang.object

类object是类层次结构的超（根）类

 每个类都是用object作为父类

所有对象包括数组都实现这个类的方法

toString : 打印字符串的相关属性，没有重写该方法的话，打印的是对象的地址值，否则打印的即字符串的相关属性即重写了tostring方法

Equals方法：

基本类型数据比较的是值

引用类型数据比较的是地址值

因为equals方法比较的是两个对象的地址值，所以没有太大意义，故而需要对这方法进行重写

Idea工具的快捷键以及一些简单的设置：

字体：file——》settings-font

背景颜色调节：

快捷键：删除一行ctrl+Y

退出任何窗口都可以使用esc键

任何新增新建的快捷键alt+insert

窗口变大变小ctrl+shift+F12

Alt+左右箭头切换class文件

运行ctrl+shift+F10

提示方法的参数CTRL+P

Final修饰的类无法被继承；

final修饰的方法不能被覆盖重写；

final修饰的局部变量只能被赋值一次；

final修饰的引用一旦指向某个对象，就不能再指向其他对象但该引用指向的对象内部的数据可以被改变；

final修饰的实例变量在定义时就需要手动赋值，或者在系统赋值之前为其赋值即编写过程中的赋值要早于系统默认赋值即早于系统给的无参构造方法赋值之前；

Final修饰的实例变量一般会和static联合使用，成为常量：

Public static final string COUNTRY_NAME=“中国”

抽象类

1. 抽象类定义：抽象类是把类之间具有的共同特征提取出来形成的，抽象类是无法创建对象的，即无法实例化，需要实现类来继承对该类进行实现
2. 抽象类也属于引用数据类型
3. 抽象类的定义：

修饰符列表 abstract class 类名{

类  体；

}

1. abstract和final两个是对立的，不能同时使用
2. 抽象类的子类可以是抽象类，也可以是实现类
3. 抽象类虽然本身无法进行实例化，但是含有构造方法，供子类进行创建对象使用
4. 抽象类关联到一个概念：抽象方法。

抽象方法表示没有实现的方法，没有方法体的方法，定义格式如：

Public abstract void doSome();

抽象方法额特点是：

1. 没有方法体，以分号结尾；
2. 前面的修饰符列表中有abstract关键字

1. 抽象类中不一定有抽象方法，但是抽象方法一定在抽象类中
2. 一个非抽象类，继承抽象类，必须将抽象类中的抽象方法进行覆盖/重写/实现.

面相抽象编程：

调用A.XXX，A是抽象类的，面向抽象编程，不要面向具体编程，降低程序的耦合度，提尕程序的扩展力，这样的编程思想符合OCP原则

接口

一、基础语法：

1. 接口也是一种引用数据类型，编译之后也是.class文件
2. 接口也是完全抽象的。（抽象类是半抽象）或者也可以说接口是一种特殊的抽象类
3. 接口的定义方式：

【修饰符列表】interface 接口名{}

1. 接口支持单继承，也支持多继承；
2. 接口中只包含两部分内容，一部分是常量，一部分是抽象方法
3. 接口中所有的元素的都是public修饰的，即都是公开的
4. 接口中的抽象方法定义时，public abstract修饰符可以省略
5. 接口中的方法都是抽象方法，所以接口中的方法不能有方法体，即没有“{}”
6. 接口中定义常量时可以省略public abstract final，但是常量值不能被修改。
7. 当一个非抽象的类实现接口时，必须将接口中的所有方法都重写（实现、覆盖）接口和接口之间恶意实现多继承，
8. 一个类亦可以实现多个接口，弥补了java中类与类之间的单继承缺陷
9. Extends和implement可以共存，extends在前，implement在后
10. 使用接口在编程过程中可以使用多态

类和类之间叫做继承，类和接口之间叫做实现

继承使用关键字extends完成

实现使用关键字implement完成

接口中的方法都是公共的

接口和接口之间进行强制类型转换的时候，没有继承也可以进行强转，但是运行时可能会出现ClassCastException异常

• 接口在开发过程中的作用

1. 接口在开发中的作用类似于多态的作用。
2. 多态：面向抽象进行编程，不要面向具体编程。降低程序额的耦合度，提高程序的扩展力，符合OCP开发原则，接口的使用离不开多态机制
3. 接口可以解耦合，任何一个接口都有调用者和实现者，接口可以将调用者和实现者解耦合，调用者面向接口调用，实现者面向接口编写实现；

• 类和类之间的关系

1、Is a、has a 、like a

2、Is a ：表示继承

3、Has a：表示关联关系，属性形式存在

4、Like a：表示实现关系，类实现接口

抽象类和接口有什么区别

1、抽象类是半抽象的，接口是完全抽象的；

2、抽象类中有构造方法，接口中没有构造方法；

3、接口和接口之间能支持多继承，类和类之间只能实现单继承；

4、一个类可以实现多个接口，一个抽象类只能继承一个类（单继承）；

5、接口中只允许出现常量和抽象方法

关于java语言中的package和import机制

1. Package是java中的包机制，作用是为了方便程序的管理不同功能的分别存放在不同的包下；
2. Package是一个关键字，后面家包名
3. 包名的命名规范：一般是采用公司域名倒叙的方式

Object类中的几个主要的方法

Protected Object clone()   //负责对象克隆的

Int hashCode()          //获取对象哈希值的方法

boolean equals(Object obj) //判断两个对象是否相等

String toString()         //将对象转换成字符串的形式

Protected void finalize()   //垃圾回收器负责调用的方法

1、String toString()        //将对象转换成字符串的形式

public String toString(){getClass().getName() + '@' + Integer.toHexString(hashCode())}
//重写toString()方法之后，年月日方才会以日期的形式显示，否则输出的是Demo05.myTime@14ae5a5即myTime@+地址值public String toString(){return this.year+"年"+this.month+"月"+this.day+"日";}

1. boolean equals(Object obj) //判断两个对象是否相等

public boolean equals(Object obj){Return (this==obj);
}

//实际上String也是一个类，不属于基本引用类型，并且String类有其本身的构造方法

1. finalize()方法：

Protected void finalize() throws Throwsble{}

此方法是protected修饰的,此方法只有一个方法体，内部没有代码，而且这个方法是用protected修饰的，该方法不需要程序员手动调用，JVM的垃圾回收器负责调用此方法。

静态代码块在类加载时执行，并且只执行一次。：

Static{

........

}

4、Int hashCode()          //获取对象哈希值的方法

在object中hashCode方法：

Public native int hashCode();

这个方法不是抽象方法，带有native关键字底层调用C++程序，调用之后会放回一个哈希值

匿名内部类：

内部类：在类的内部定义了一个新的类

内部类分类（三种）：

静态内部类：类似于静态变量

实例内部类：类似于实例变量

局部内部类：类似于局部变量

class Test01{

//静态内部类

Static class Inner1{

}

//实例内部类

class Inner2{

}

Public void doSome(){

Int i=100

//局部内部类

class inner3

}

}

  数组 

1. 数组的优点和缺点：

第一：空间存储上，内存地址是连续的。

第二：每个元素占用的空间大小相同。

第三：知道首元素的内存地址。

第四：通过下标可以计算出偏移量。

通过一个数学表达式，就可以快速计算出某个下表位置上元素的内存地址。

直接通过内存地址定位，效率高

优点：检索效率高

缺点：随机增删效率非常低，数组无法存储大量的数据

注意：数组的最后一个元素的增删效率不受影响。

1. 一维数组的静态初始化和动态初始化

静态初始化：

Int 【】 a={1,2,3,4};

Object[] objs={new Object(),new Object(),new Object()};

动态初始化：

int [] a=new int [5];//5个长度的数组，每个元素的默认值都是0

Object[] objs=new Object[4];//4个长度，每个元素的默认值都是null

1. 一维数组的遍历：

Int a[]=new int[4];for (int i = 0; i < a.length; i++) {System.out.println(a[i]);}

1. 二维数组的静态和动态初始化：

静态初始化;

int [][] a={{100,200,4,300},{1,2,6,4},{4,5,68,9}};

动态初始化：

int[][] a= new int[3][4];//动态初始化数组

Int[][] a=new int[3][4];

1. 二维数组的遍历：

int[][] a= new int[3][4];for (int i = 0; i < a.length; i++) {for (int j = 0; j < a[i].length; j++) {System.out.println(a[i][j]);}System.out.println();}

1. 数组的扩容;

 关于java中数组的扩容：* 在java中，数组的长度一旦确定就不可变，当数组满了的时候，需要扩容* java中数组的扩容是：*       先创建一个更大容量的数组，然后将原来数组内的所有数据进行全部拷贝* 数组的扩容效率较低，设计拷贝问题,拷贝方法： System.arraycopy();* */
public class ArrayTest07 {public static void main(String[] args) {int [] src={1,11,2,3,4};int[] dest=new int [8];//数组的扩容方法System.arraycopy(src,0,dest,1,src.length);//遍历目标数组for (int i = 0; i <dest.length ; i++) {System.out.println(dest[i]);}}}

数组常见的算法

7.1排序算法：

冒泡排序算法

选择排序算法

查找算法：

二分法查找

7.2、算法实际上在java中已经封装好了，如果需要排序，只调用方法就行。例如：java中提供了一个数组的工具类：

Java.util.Arrays

Arrays是一个工具类

其中有一个sort（）方法，可以排序。静态方法，直接使用类名调用就行。

7.3、选择排序：

选择排序比冒泡排序的效率高。

高在交换位置的次数上。

选择排序的交换位置是有意义的。

循环一次，然后找出参加比较的这堆数据中最小的，拿着这个最小的数据和前面的数据进行交换位置。

 枚举

1. 枚举是一种引用数据类型
2. 枚举类型的定义语法：

enum 枚举类型名称{

枚举值1，枚举值2，····

}

1. 结果只有两种情况的，建议使用布尔类型。
2. 结果超过两种并且还可以一种一种列举出来的，建议使用枚举类型。

异常

异常在java中是以类的形式存在的，可以创建对象

Final\finally\finalize:

Final：关键字，修饰的变量无法重新赋值、修饰的方法不能被覆盖、修饰的类不能被继承

Finally：关键字，与try联合使用，finally中的语句一定要执行

Finalize:标识符，是一个OBject类中的一个方法名，由GC垃圾回收器负责调用。

经典异常：空指针异常：NullPointerException类型转换异常ClasscastException数组下标越界异常：ArrayIndexOutOfBoundsException数字格式化异常：NumberFormatException

总结异常中的关键字：

异常捕捉：try\catch\finally

Throws:在方法声明的位置上使用，表示上报异常信息给调用者

Throw: 手动抛出异常

集合

1. 数组实际上是一种集合，是一种数据的容器。可以一次容纳多个对象
2. 集合不能直接存储基本数据类型，也不能直接存储java对象，当中存储的是java对象的地址，即存储的是引用数据类型。集合也可以是一个对象，也有内存地址。
3. 在java中，每一个不同的集合，底层会对应不同的数据结构，网不通的集合中存储元素，等于将数据放到了不同的数据结构当中。
4. 集合在java.util包下，所有的接口和类
5. 在java中结合分为两大类：

一类是单个方式存储元素：这一类集合中超级父接口：java.util.Collection

一类是以键值对的方式进行存储元素：这一类集合中超级父接口：java.util.Map

集合中的重要内容

1. 主要的集合类：

Arraylist

Linkedlist

HashSet

HashMap

TreeMap

TreeSet

Properties

1. 集合的创建
2. 向集合中添加元素
3. 取出集合中的元素
4. 集合的遍历

IO流：

什么是IO？

        I:Input    O：output

IO流的分类：

        一种是按照流的方向进行分类;

        以内存作为参照物

        往内存中去问，叫做输入（Input）