Java基础知识
1、object类相关方法
- getClass : 获取当前运行时对象的Class 对象。
- hashCode ：返回对象的hash码。
- clone：拷贝当前对象，必须实现Cloneable接口。
- 浅拷贝：对基本类型 ----值拷贝 ；对引用类型—拷贝引用。
- 深拷贝：对基本类型----值拷贝；对引用类型----拷贝对象的引用和对象的属性和方法，深拷贝创建了一个新的对象。
- equals：通过内存地址比较两个对象是否相等，String类重写了这个方法 使用值来比较是否相等。
- toString：返回类名@哈希码的16进制。
- notify：唤醒当前对象监视器的任意一个线程。
- notifyAll： 所有线程。
- wait：①暂停线程执行；②三个不同参数的方法（等多少ms；额外等多少ms；一直等待）；③与Thread.sleep相比，sleep使当前线程休眠一段时间，没有释放该对象的锁，而wait释放了对象的锁。
- finalize：对象被垃圾回收器回收时执行的方法。
2、基本数据结构
基本数据类型有8种，包括6中数字类型、一个字符类型和一个布尔类型
数字类型包括 4 种整数类型和 2 种浮点数类型，4 种整数类型是 byte、short、int 和 long，2 种浮点数类型是 float 和 double;字符类型是 char，用于表示单个字符。Java 使用统一码对字符进行编码。布尔类型是 boolean，包括 true 和 false 两种取值。
数据类型转换
将小范围类型的变量转换为大范围类型称为拓宽类型，不需要显性声明类型转换。将大范围类型的变量转换为小范围类型称为缩窄类型，必须显性声明类型转换，否则会导致编译错误。
字符类型与数字类型之间的转换
将数字类型转换成字符类型时，只使用整数的低 16 位（浮点数类型将整数部分转换成字符类型）。
将字符类型转换成数字类型时，字符的统一码转换成指定的数值类型。如果字符的统一码超出了转换成的数值类型的取值范围，则必须显性声明类型转换。
3、序列化
- 反序列化并不会调用构造方法。反序列的对象是由 JVM 自己生成的对象，不通过构造方法生成。
- 序列化对象的引用类型成员变量，也必须是可序列化的，否则，会报错。
- 如果想让某个变量不被序列化，使用 transient 修饰。
- 单例类序列化，需要重写 readResolve() 方法。
详解：( 序列化&utm_medium=distribute.pc_search_result.none-task-blog-2allsobaiduweb~default-0-81630052.nonecase&spm=1018.2226.3001.4187)
4、String StringBuffer StringBuilder
- String： 由 char[] 数组构成，使用了 final 修饰，是不可变对象，可以理解为常量，线程安全；对 String 进行改变时每次都会新生成一个 String 对象，然后把指针指向新的引用对象。
String a = "123";
a = "456";
// 打印出来的a为456
System.out.println(a)
- StringBuffer：StringBuffer对象则代表一个字符序列可变的字符串，当一个StringBuffer被创建以后，通过StringBuffer提供的append()、insert()、reverse()、setCharAt()、setLength()等方法可以改变这个字符串对象的字符序列。一旦通过StringBuffer生成了最终想要的字符串，就可以调用它的toString()方法将其转换为一个String对象。
StringBuffer b = new StringBuffer("123");
b.append("456");
// b打印结果为：123456
System.out.println(b);
- StringBuilder:StringBuilder类也代表可变字符串对象。实际上，StringBuilder和StringBuffer基本相似，两个类的构造器和方法也基本相同。不同的是：StringBuffer是线程安全的，而StringBuilder则没有实现线程安全功能，所以性能略高。
StringBuffer类中的方法都添加了synchronized关键字，也就是给这个方法添加了一个锁，用来保证线程安全。
5、重载和重写
重写
重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变，即外壳不变，核心重写！
子类可以根据需要，定义特定于自己的行为，根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如： 父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，抛出 IOException 异常或者 IOException 的子类异常。在面向对象原则里，重写意味着可以重写任何现有方法。
重写规则
- 参数列表与被重写方法的参数列表必须完全相同
- 返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类
- 访问权限不能比父类中被重写的方法的访问权限更低。
- 父类的成员方法只能被它的子类重写。
- 声明为 final 的方法不能被重写，声明为 static 的方法不能被重写，但是能够被再次声明。
- 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
- 子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
- 如果不能继承一个类，则不能重写该类的方法。
- 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
- 构造方法不能被重写。
当子类调用父类的被重写方法时，使用Super关键字。例：
class Animal{
public void move(){
System.out.println("动物可以移动");
}
}
class Dog extends Animal{
public void move(){
super.move(); // 应用super类的方法
System.out.println("狗可以跑和走");
}
}
public class TestDog{
public static void main(String args[]){
Animal b = new Dog(); // Dog 对象
b.move(); //执行 Dog类的方法
}
}
动物可以移动
狗可以跑和走重载（overload）
重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。
每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。
最常用的地方就是构造器的重载。
重载规则
- 被重载的方法必须改变参数列表(参数个数或类型不一样)；
- 被重载的方法可以改变返回类型、访问修饰符；
- 被重载的方法可以声明新的或更广的检查异常；
- 方法能够在同一个类中或者在一个子类中被重载；
- 无法以返回值类型作为重载函数的区分标准。
public class Overloading {
public int test(){
System.out.println("test1");
return 1;
}
public void test(int a){
System.out.println("test2");
}
//以下两个参数类型顺序不同
public String test(int a,String s){
System.out.println("test3");
return "returntest3";
}
public String test(String s,int a){
System.out.println("test4");
return "returntest4";
}
public static void main(String[] args){
Overloading o = new Overloading();
System.out.println(o.test());
o.test(1);
System.out.println(o.test(1,"test3"));
System.out.println(o.test("test4",1));
}
}重载与重写的区别
区别点 | 重载方法 | 重写方法 |
参数列表 | 必须修改 | 一定不能修改 |
返回类型 | 可以修改 | 一定不能修改 |
异常 | 可以修改 | 可减少或删除，一定不能抛出新的或更广的异常 |
访问 | 可以修改 | 一定不能做更严格的限制 |
总结
方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。
- 方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
- 方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
- 方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。
6、final
- 修饰基本类型变量，一经出初始化后就不能够对其进行修改。
- 修饰引用类型变量，不能够指向另一个引用。
- 修饰类，不能被继承。
final类的成员方法没有机会被覆盖，默认都是final的，在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会再被扩展，那么就设计为final类。 final方法不能被子类的方法覆盖，但可以被继承。
如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。 使用final方法的原因有二： 第一、把方法锁定，防止任何继承类修改它的意义和实现。 第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。
final变量（常量） 用final修饰的成员变量表示常量，只能被赋值一次，赋值后值无法改变！ final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。 从下面的例子中可以看出，一旦给final变量初值后，值就不能再改变了。 另外，final变量定义的时候，可以先声明，而不给初值，这种变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。
7、反射
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种**动态获取的信息以及动态调用对象**的方法的功能称为java语言的反射机制。
要想解剖一个类,必须先要获取到该类的字节码文件对象。而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象。
反射就是将java类中的各种成分映射成一个个的Java对象。
实例
package fanshe;
/**
* 获取Class对象的三种方式
* 1 Object ——> getClass();
* 2 任何数据类型（包括基本数据类型）都有一个“静态”的class属性
* 3 通过Class类的静态方法：forName（String className）(常用)
*/
public class Fanshe {
public static void main(String[] args) {
//第一种方式获取Class对象
Student stu1 = new Student();//这一new 产生一个Student对象，一个Class对象。
Class stuClass = stu1.getClass();//获取Class对象
System.out.println(stuClass.getName());
//第二种方式获取Class对象
Class stuClass2 = Student.class;
System.out.println(stuClass == stuClass2);//判断第一种方式获取的Class对象和第二种方式获取的是否是同一个
//第三种方式获取Class对象
try {
Class stuClass3 = Class.forName("fanshe.Student");//注意此字符串必须是真实路径，就是带包名的类路径，包名.类名
System.out.println(stuClass3 == stuClass2);//判断三种方式是否获取的是同一个Class对象
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}注意：在运行期间，一个类，只有一个Class对象产生。
三种方式常用第三种，第一种对象都有了还要反射干什么。第二种需要导入类的包，依赖太强，不导包就抛编译错误。一般都第三种，一个字符串可以传入也可写在配置文件中等多种方法。
通过反射可以获取类的构造方法
所有公有的构造方法：getConstructors()
所有的构造方法（public、default、protected、private）：getDeclaredConstructors()
获取公有、无参的构造方法：getConstructors(null)
获取单个方法：getDeclaredConstructor(Class parameterType)
获取成员变量并调用
- 批量的：Field[ ] getFields() 获取所有公有字段
Field [ ]getDeclaredFields() 获取所有字段
- 获取单个的 getField（String FieldName）
getDeclaredField(String FieldName) - 设置字段值 set（Object object，Object value）—-（字段所在对象，字段设置值）
获取成员方法并调用
- 批量的：getMethods（）获取所有公有方法
getDeclaredMethods（）获取所有成员方法包括私有 - 单个的：getMethod（String name ，Class parameterTypes）
getDeclaredMethods（String name ，Class parameterTypes） - 调用方法：public Object invoke（Object obj，object 。。。args）—–（要调用的方法对象，调用方式时所传递的参数）
通过反射运行配置文件内容
Student类
public class Student {
public void show(){
System.out.println("is show()");
}
}配置文件以txt文件为例子（pro.txt）：
className = cn.fanshe.Student
methodName = show测试类：
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.lang.reflect.Method;
import java.util.Properties;
/*
* 我们利用反射和配置文件，可以使：应用程序更新时，对源码无需进行任何修改
* 我们只需要将新类发送给客户端，并修改配置文件即可
*/
public class Demo {
public static void main(String[] args) throws Exception {
//通过反射获取Class对象
Class stuClass = Class.forName(getValue("className"));//"cn.fanshe.Student"
//2获取show()方法
Method m = stuClass.getMethod(getValue("methodName"));//show
//3.调用show()方法
m.invoke(stuClass.getConstructor().newInstance());
}
//此方法接收一个key，在配置文件中获取相应的value
public static String getValue(String key) throws IOException{
Properties pro = new Properties();//获取配置文件的对象
FileReader in = new FileReader("pro.txt");//获取输入流
pro.load(in);//将流加载到配置文件对象中
in.close();
return pro.getProperty(key);//返回根据key获取的value值
}
}控制台输出：isShow（）
**需求：**当我们升级这个系统时，不要Student类，而需要新写一个Student2的类时，这时只需要更改pro.txt的文件内容就可以了。代码就一点不用改动。
要替换的类
public class Student2 {
public void show2(){
System.out.println("is show2()");
}
}配置文件
className = cn.fanshe.Student2
methodName = show2控制台输出： isShow2（）
通过反射越过泛型检查
泛型用在编译期，编译过后泛型擦除（消失掉）。所以是可以通过反射越过泛型检查的
import java.lang.reflect.Method;
import java.util.ArrayList;
/*
* 通过反射越过泛型检查
*
* 例如：有一个String泛型的集合，怎样能向这个集合中添加一个Integer类型的值？
*/
public class Demo {
public static void main(String[] args) throws Exception{
ArrayList<String> strList = new ArrayList<>();
strList.add("aaa");
strList.add("bbb");
// strList.add(100);
//获取ArrayList的Class对象，反向的调用add()方法，添加数据
Class listClass = strList.getClass(); //得到 strList 对象的字节码 对象
//获取add()方法
Method m = listClass.getMethod("add", Object.class);
//调用add()方法
m.invoke(strList, 100);
//遍历集合
for(Object obj : strList){
System.out.println(obj);
}
}
}控制台输出：aaa bbb 100
8、动态代理
使用步骤
- 创建接口及实现类
- 实现代理处理器：实现 InvokationHandler ，实现 invoke（Proxy proxy，Method method，Object[] args） 方法
- 通过 Proxy.newProxyInstance(ClassLoaderloader, Class[] interfaces, InvocationHandler h) 获得代理类
- 通过代理类调用方法。
什么是代理
代理是一种常用的设计模式，目的就是为其他对象提供一个代理，以控制对某个对象的访问。
代理类的主要职责：
- 为委托类预处理消息
- 过滤并转发消息
- 进行消息被委托类执行后的后续处理
为了保持行为的一致性，代理类和委托类通常会实现相同的接口，所以在访问者看来两者没有丝毫的区别。通过代理类这中间一层，能有效控制对委托类对象的直接访问，也可以很好地隐藏和保护委托类对象，同时也为实施不同控制策略预留了空间，从而在设计上获得了更大的灵活性。Java 动态代理机制以巧妙的方式近乎完美地实践了代理模式的设计理念。
Java动态代理类
- Interface InvocationHandler：该接口中仅定义了一个方法
public object invoke(Object obj,Method method, Object[] args)在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，args为该方法的参数数组。这个抽象方法在代理类中动态实现。
2.Proxy：该类即为动态代理类，其中主要包含以下内容：
protected Proxy(InvocationHandler h)：构造函数，用于给内部的h赋值。
static Class getProxyClass (ClassLoaderloader, Class[] interfaces)：获得一个代理类，其中loader是类装载器，interfaces是真实类所拥有的全部接口的数组。
static Object newProxyInstance(ClassLoaderloader, Class[] interfaces, InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用(可使用被代理类的在Subject接口中声明过的方法)
所谓DynamicProxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然，这个DynamicProxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。
在使用动态代理类时，我们必须实现InvocationHandler接口
通过这种方式，被代理的对象(RealSubject)可以在运行时动态改变，需要控制的接口(Subject接口)可以在运行时改变，控制的方式(DynamicSubject类)也可以动态改变，从而实现了非常灵活的动态代理关系。
动态代理步骤：
1.创建一个实现接口InvocationHandler的类，它必须实现invoke方法
2.创建被代理的类以及接口
3.通过Proxy的静态方法newProxyInstance(ClassLoaderloader, Class[] interfaces, InvocationHandler h)创建一个代理
4.通过代理调用方法JDK动态代理的使用
9、JavaIO
10、后话
本片文章只为记录自己学习过程，无其它用途，若有不对还请评论多多指正。
