八大基本类型

1.自动类型提升:当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。

byte、short、char–>int–>long–>float–>double

特别的：当byte、char、short三种类型的变量做运算时，结果为int型

说明：此时的容量大小指的是，表示数的范围的大和小。int(-2^31~~2^31-1) > short(-2^7~~2^7-1)

2.强制类型转换:自动类型转换的逆运算。

1.需要使用强制转换符()

2.注意点：强制类型转换，可能导致精度损失。

面向对象

1.面向过程和面向对象的区别

面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。

面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

例子：一个公司从小发展到大公司的过程(面向过程—->面向对象)

2.类（Class）和对象（Object）

类是对一类事物的描述，是抽象的、概念上的定义。例如：人类

对象是实际存在的该类事物的每个个体，因而也称为实例。例如：温志浩

3.类中常见的成员有：

属性（field）：对应类中的成员变量。

方法（method）：对应类中的成员方法。

构造器（constructor）作用：创建对象、初始化对象信息。

……….

4.面向对象特征：

问题的引入：当我们创建一个对象以后，可以通过对象.属性的方式进行赋值。例如：我们给人类的对象的年龄属性进行赋值的时候，需要加入年龄不能小于0的条件，即要添加约束的条件。我们无法在属性的声明时期直接进行添加约束条件，所以引入封装。

封装性的体现：（封装性是一个很广的概念，以下每一种都是封装性的体现）

我们将类的属性私有化(private)，同时提供公共的(public方法来获取(get)和设置(set)
不对外暴露的私有的方法。
单例模式
……

问题的引入：当我们创建出了一个银行卡对象的时候，银行卡可以分为储蓄卡、信用卡。但是它们的属性和方法有很多是相同的，那么我们就要在分别的各自的类中又写一样的属性和方法。在增加一种卡型的时候也要再写一遍相同的属性和方法。代码的复用性太低。所以我们引入继承。

继承性：从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力。

一旦子类A继承父类B以后，子类A中获取了父类B中的所有的属性和方法。就算父类中是private的属性和方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只有因为封装性的影响，导致子类不能直接调用父类的结构而已。
子类继承父类以后，还可以声明自己特有的方法或属性，实现功能的扩展。

多态性：对象的多态性：父类的引用指向子类型的对象(Person p=new Man();)当我们new对象的时候，前面是父类，后面可以是子类。

多态的使用：当调用子父类同名的参数方法时，实际执行的是子类重写父类的方法。（我们在编译期，只能调用父类中声明的方法，但在运行期，我们执行的是子类重写父类的方法。总结：编译，看左边；运行，看右边。）
多态使用的前提：1.类的继承关系 2.方法重写（如果你子类中不重写父类的方法，那么不如直接new 父类）

若我们没有多态性，那么这个方法中需要的是Animal类，那么就只能放animal的对象进去。当我们想放猫的时候，又要在写一个需要的是Cat类的方法，需要的是Dog类又要另外写一个方法。这也就是多态的优点。
3.对象的多态性，只适用于方法，不适用于属性。（编译期和运行期都看左边）

抽象类：随着继承层次中一个个新子类的定义，子类变得越来越具体，而父类则更一般，更通用。慢慢的这个类就不在用来实例化了。

例子：一个公司从小规模的时候老板做很多事情，后来公司变大了，老板慢慢就做的事情少了。此时老板就是抽象类。

abstract：抽象的
abstract可以用来修饰类和方法
abstract修饰的类：抽象类
1. 此类不能实例化
2. 抽象类中一定有构造器（虽然自己以及不能new对象了，但是子类在new对象的时候，必须通过父类的构造器）
3. 必须提供抽象类的子类，让子类对象实例化。（不然抽象类本来就不能造对象，还没有子类。这用来干嘛呢？
abstract修饰方法：抽象方法
1. 抽象放只有方法的声明，没有方法体。（参考接口）
2. 包含抽象方法的类必须是抽象类。但抽象类中可以没有抽象方法。
3. 若子类不为抽象类，那么就必须重写所有父类（无论直接、间接父类）中的抽象方法。

问题引入：在Java中，只能够单继承，那么能实现的功能就变得很少，比如：篮球运动员和足球运动员都有了运动员继承了运动员这个父类。语文课代表和数学课代表都继承了班委这个父类。但是它们又还有学生这个类，那我们又不能进行继承。所以引入接口概念。接口可以多实现。

接口：

接口使用interface来定义
接口中有：全局常量、抽象方法
接口中不能定义构造器的
实现类要实现接口中的所有方法。
重写和实现：对接口或抽象类中中有方法体的方法叫重写，对没有方法体的方法叫实现
可以多实现–》弥补了单继承的局限

接口和抽象类的对比：

相似点：

接口和抽象类都不能被实例化。
接口和抽象类都可以包含抽象方法

不同点：

接口里只能包含抽象方法，抽象类则可以包含普通方法
抽象类中的成员变量可以是各种类型的，接口中的成员变量只能常量
接口不能包含构造器，抽象类可以包含构造器
一个类只能继承一个抽象类，而一个类却可以实现多个接口。

多线程

程序：一段静态的代码

进程：正在运行的一个程序。是一个动态的过程。

系统在运行时会为每个进程分配不同的内存区域。

线程：进程可以进一步细分为线程，是一个程序内部的一条执行路径。

每个线程拥有独立的运行栈和和程序计数器。

多线程的创建：

继承Thread类
1. 创建一个继承于Thread类的子类
2. 重写Thread类的run()
3. 创建Thread类的子类对象
4. 通过此对象调用start()
实现Runnable接口
1. 创建一个实现了Runnable接口的类
2. 实现类去实现Runnable中的抽象方法：run()
3. 创建实现类的对象
4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象。(这个和继承的方式不同)
5. 通过Thread类的对象调用start()
实现Callable
1. 最大的区别，runnable没有返回值，而实现callable接口的任务线程能返回执行结果
2. callable接口实现类中的run方法允许异常向上抛出，可以在内部处理，try catch，但是runnable接口实现类中run方法的异常必须在内部处理，不能抛出

线程的生命周期：

类加载器：

bootstrap ClassLoader（启动类加载器）是ExtClassLoader的父类加载器，负责加载核心类库

ExtClassLoader（扩展类加载器）是AppClassLoader的父类加载器，负责加载ext文件夹在的类库

AppClassLoader(系统类加载器)是负责加载classpath下的类文件。

双亲委派:

如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器，如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式，即每个儿子都很懒，每次有活就丢给父亲去干，直到父亲说这件事我也干不了时，儿子自己想办法去完成。

String的使用：

String类上声明为final的，不可被继承。
String实现了Serializable接口：表示字符串是支持序列化的。
实现了Comparable接口：表示String可以比较大小。
String内部定义了final char[] value用于存储字符串数据
String：代表不可变的字符序列。简称：不可变性
5.1 当对字符串重新赋值时，需要在字符串常量池中创建一个新的区域，不能使用原有的value进行赋值。
5.2 当对现有的字符串进行连接操作时，也需要重新指定内存区域，不能使用原有的value进行赋值。
5.3 当调用String的replace()方法进行修改指定字符或字符串时，也需要重新指定内存区域，不能使用原有的value进行赋值。
通过字面量的方式（String s=”abc”，和new是不同的）给一个字符串赋值，此时的字符串值是声明在字符串常量池中。
字符串常量池中是不会存储相同内容的字符串的。(参考Map的Key值)
通过字面量定义的方式：数据是存放在方法区中的字符串常量池。通过new+构造器的方式：数据是存放在堆空间中。

IO流：

IO流体系：

网络通信协议：

传输层中两个重要的协议：TCP(Transmission Control Protocol)传输控制协议/UDP(User Datagram Protocol)用户数据报协议。

TCP协议：

使用TCP协议前，必须建立TCP连接，形成传输数据通道
传输前，采用“三次握手”方式，点对点通信，是可靠的
TCP协议进行通信的两个应用进程：客户端、服务端
在连接中可进行大数据量的传输
传输完毕，需释放已建立的连接，效率低

UDP协议：

将数据封装成数据包，不需要建立连接
每个数据报的大小限制在64k内
发送不管对方是否准备好，接收方收到也不确认，故是不可靠的
可以广播发送
发送数据结束时无需释放资源，开销小，速度快

Java基础