java基础笔记

基础

---

面向对象主要有四大特性

1、抽象

忽略一个主题中与当前目标无关的东西，专注的注意与当前目标有关的方面。(就是把现实世界中的某一类东西，提取出来，用程序代码表示，抽象出来的一般叫做类或者接口)。抽象并不打算了解全部问题，而是选择其中的一部分，暂时不用部分细节。抽象包括两个方面，一个数据抽象，而是过程抽象。抽象只关注对象有哪些属性和行为，并不关注这些行为的细节是什么。

数据抽象 -->表示世界中一类事物的特征，就是对象的属性。比如鸟有翅膀，羽毛等(类的属性)

过程抽象 -->表示世界中一类事物的行为，就是对象的行为。比如鸟会飞，会叫(类的方法)

2、封装

封装是面向对象的特征之一，是对象和类概念的主要特性。封装就是把过程和数据包围起来，对数据的访问只能通过已定义的界面。如私有变量，用set，get方法获取。封装就是隐藏一切可隐藏的东西，只向外界提供最简单的编程接口

封装保证了模块具有较好的独立性，使得程序维护修改较为容易。对应用程序的修改仅限于类的内部，因而可以将应用程序修改带来的影响减少到最低限度。

3、继承

继承为了重用父类代码，同时为实现多态性作准备。继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类（超类、基类）；得到继承信息的类被称为子类（派生类）。继承让变化中的软件系统有了一定的延续性，同时继承也是封装程序中可变因素的重要手段。

4、多态

多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。多态性语言具有灵活/抽象/行为共享/代码共享的优势，很好的解决了应用程序函数同名问题。总的来说，方法的重写，重载与动态链接构成多态性。java引入多态的概念原因之一就是弥补类的单继承带来的功能不足。

动态链接 -->对于父类中定义的方法，如果子类中重写了该方法，那么父类类型的引用将调用子类中的这个方法，这就是动态链接。

面向对象五大基本原则是什么

单一职责

从字面意思其实就很好理解，只做一件事，不去多揽其他的事使自己烦心；单一职责原则可以看做是低耦合高内聚思想的延伸，提高高内聚来减少引起变化的原因。

开放封闭原则

在设计一个类或者一个模块，应该符合对外是可以扩展的，对修改时关闭的，这样的代码健壮性就很强，后续业务扩展增加新的需求也可以在保证现有代码不变的情况下实现扩展。

里氏替换原则

里氏替换原则对继承进行了规则上的约束，这种约束主要体现在四个方面：

        1. 子类必须实现父类的抽象方法，但不得重写（覆盖）父类的非抽象（已实现）方法。

        2. 子类中可以增加自己特有的方法。

        3. 当子类覆盖或实现父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。

        4. 当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。

接口隔离原则

接口端不应该依赖它不需要的接口，一个类对另一个类的依赖应该建立在最小的接口上。

如果一个提供接口的类中对于它的子类来说不是最小的接口，那么它的子类在实现该类的时候就必须实现一些自己不需要的功能，整个系统就会慢慢变得臃肿难以维护。

依赖倒置原则

1. 高层次的模块不应该依赖低层次的模块，他们都应该依赖于抽象
2. 抽象不应该依赖于具体实现，具体实现应该依赖于抽象

java三大特征

1、封装

2、继承

3、多态

JDK 6 新特性

JDK 7的新特性

JDK8 的新特性

 什么是Java程序的主类？应用程序和小程序的主类有何不同？

一个程序中可以有多个类，但只能有一个类是主类。在Java应用程序中，这个主类是指包含main()方法的类。

而在Java小程序中，这个主类是一个继承自系统类JApplet或Applet的子类。应用程序的主类不一定要求是public类，但小程序的主类要求必须是public类。主类是Java程序执行的入口点。

数据类型四类八种

	数据类型	包装类	占用内存	取值范围	默认值
整型	byte	Byte	1个字节	-2^7 ~ 2^7-1	0
	short	short	2个字节	-2^15 ~ 2^15-1	0
	int	Integer	4个字节	-2^31 ~ 2^31-1	0
	long	Long	8个字节	-2^63 ~ 2^63-1	0L
浮点型	float	Float	4个字节	（正数）1.4E-45 - 3.4028235E38 （整体） -3.4028235E38 ~ 3.4028235E38	0.0F
	double	Double	8个字节	1.7976931348623157E308 ~ 4.9E-324	0.0D
字符型	char	Character	2个字节	65536（看字符编码）	'\u0000'
布尔型	boolean	BOOlean	1个字节	两个值 true和false	false

1. Java 里使用 long 类型的数据一定要在数值后面加上 L，否则将作为整型解析。
2. char a = 'h'char :单引号，String a = "hello" :双引号。

基本类型和包装类型的区别？

• 成员变量包装类型不赋值就是 null ，而基本类型有默认值且不是 null。
• 包装类型可用于泛型，而基本类型不可以。
• 基本数据类型的局部变量存放在 Java 虚拟机栈中的局部变量表中，基本数据类型的成员变量（未被 static 修饰 ）存放在 Java 虚拟机的堆中。包装类型属于对象类型，我们知道几乎所有对象实例都存在于堆中。
• 相比于对象类型， 基本数据类型占用的空间非常小。

为什么说是几乎所有对象实例呢？ 这是因为 HotSpot 虚拟机引入了 JIT 优化之后，会对对象进行逃逸分析，如果发现某一个对象并没有逃逸到方法外部，那么就可能通过标量替换来实现栈上分配，而避免堆上分配内存

⚠️ 注意 ： 基本数据类型存放在栈中是一个常见的误区！ 基本数据类型的成员变量如果没有被 static 修饰的话（不建议这么使用，应该要使用基本数据类型对应的包装类型），就存放在堆中。

第一条：八种基本数据类型中，除 boolean 类型不能转换，剩下七种类型之间都可以进行转换；

第二条：如果整数型字面量没有超出 byte,short,char 的取值范围，可以直接将其赋值给byte,short,char 类型的变量；

第三条：小容量向大容量转换称为自动类型转换，容量从小到大的排序为：
byte < short(char) < int < long < float < double，其中 short和 char 都占用两个字节，但是char 可以表示更大的正整数；

第四条：大容量转换成小容量，称为强制类型转换，编写时必须添加“强制类型转换符”，但运行时可能出现精度损失，谨慎使用；

第五条：byte,short,char 类型混合运算时，先各自转换成 int 类型再做运算；

第六条：多种数据类型混合运算，各自先转换成容量最大的那一种再做运算；

所有的笔试题都超不出以上的6条规则。死记硬背

Integer a= 127 与 Integer b = 127相等吗

对于对象引用类型：==比较的是对象的内存地址。
对于基本数据类型：==比较的是值。

如果整型字面量的值在-128到127之间，那么自动装箱时不会new新的Integer对象，而是直接引用常量池中的Integer对象，超过范围 a1==b1的结果是false

public static void main(String[] args) {
    Integer a = new Integer(3);
    Integer b = 3;  // 将3自动装箱成Integer类型
    int c = 3;
    System.out.println(a == b); // false 两个引用没有引用同一对象
    System.out.println(a == c); // true a自动拆箱成int类型再和c比较
    System.out.println(b == c); // true
 
    Integer a1 = 128;
    Integer b1 = 128;
    System.out.println(a1 == b1); // false
 
    Integer a2 = 127;
    Integer b2 = 127;
    System.out.println(a2 == b2); // true
}

String str="i"与 String str=new String("i")一样吗？

不一样，因为内存的分配方式不一样。

String str="i"的方式，Java 虚拟机会将其分配到常量池中；而 String str=new String("i") 则会被分到堆内存中。

字符型常量和字符串常量的区别

1.形式上: 字符常量是单引号引起的一个字符，字符串常量是双引号引起的若千个字符
2.含义上: 字符常量相当于一个整形值( ASCII 值),可以参加表达式运算；字符串常量代表一个地址值(该字符串在内存中存放位置，相当于对象)
3. 占内存大小：字符常量只占2个字节；字符串常量占若干个字节(至少一个字符结束标志) (注意: char 在Java中占两个字节)

String为什么是不可变的吗？

String 类是 fifinal 类，不可以被继承。

通过源码知道String 底层是由char数组构成，我们创建一个字符串对象的时候，其实是将字符串保存在char数组中，因为数组是引用对象，为了防止数组可变，jdk加了final修饰，但是加了final修饰的数组只是代表了引用不可变，不代表数组内容不可变，因此jdk为了真正防止不可变，又加了private修饰符。

String str="i"与 String str=new String(“i”)一样吗？

不一样，因为内存的分配方式不一样。String str="i"的方式，java 虚拟机会将其分配到常量池中；而 String str=new String(“i”) 则会被分到堆内存中。

String s = new String(“xyz“) 创建了几个字符串对象？

一个或两个。

如果字符串常量池已经有“xyz”，则是一个；否则，两个。

当字符串常量池没有 “xyz”，此时会创建如下两个对象：

一个是字符串字面量 "xyz" 所对应的、驻留（intern）在一个全局共享的字符串常量池中的实例，此时该实例也是在堆中，字符串常量池只放引用。

另一个是通过 new String() 创建并初始化的，内容与"xyz"相同的实例，也是在堆中。

String s = "xyz" 和 String s = new String("xyz") 区别？

两个语句都会先去字符串常量池中检查是否已经存在 “xyz”，如果有则直接使用，如果没有则会在常量池中创建 “xyz” 对象。

另外，String s = new String("xyz") 还会通过 new String() 在堆里创建一个内容与 "xyz" 相同的对象实例。

所以前者其实理解为被后者的所包含。

String 类的常用方法都有那些？

• indexOf()：返回指定字符的索引。
• charAt()：返回指定索引处的字符。
• replace()：字符串替换。
• trim()：去除字符串两端空白。
• split()：分割字符串，返回一个分割后的字符串数组。
• getBytes()：返回字符串的 byte 类型数组。
• length()：返回字符串长度。
• toLowerCase()：将字符串转成小写字母。
• toUpperCase()：将字符串转成大写字符。
• substring()：截取字符串。
• equals()：字符串比较。

java向上取整

Java 语言关键字有哪些？

分类	关键字
访问控制	private	protected	public
类，方法和变量修饰符	abstract	class	extends	final	implements	interface	native
	new	static	strictfp	synchronized	transient	volatile	enum
程序控制	break	continue	return	do	while	if	else
	for	instanceof	switch	case	default	assert
错误处理	try	catch	throw	throws	finally
包相关	import	package
基本类型	boolean	byte	char	double	float	int	long
	short
变量引用	super	this	void
保留字	goto	const

重写与重载

重写就是子类对父类方法的重新改造，外部样子不能改变，内部逻辑可以改变。

区别点	重载方法	重写方法
发生范围	同一个类	子类
参数列表	必须修改	一定不能修改
返回类型	可修改	子类方法返回值类型应比父类方法返回值类型更小或相等
异常	可修改	子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等；
访问修饰符	可修改	一定不能做更严格的限制（可以降低限制）
发生阶段	编译期	运行期

方法的重写要遵循“两同两小一大”

• “两同”即方法名相同、形参列表相同；
• “两小”指的是子类方法返回值类型应比父类方法返回值类型更小或相等，子类方法声明抛出的异常类应比父类方法声明抛出的异常类更小或相等；
• “一大”指的是子类方法的访问权限应比父类方法的访问权限更大或相等。

⭐️ 关于 重写的返回值类型 这里需要额外多说明一下，上面的表述不太清晰准确：如果方法的返回类型是 void 和基本数据类型，则返回值重写时不可修改。但是如果方法的返回值是引用类型，重写时是可以返回该引用类型的子类的。

接口和抽象类有什么共同点和区别？

共同点 ：

• 都不能被实例化。
• 都可以包含抽象方法。
• 都可以有默认实现的方法（Java 8 可以用 default 关键字在接口中定义默认方法）。

区别 ：

• 接口主要用于对类的行为进行约束，你实现了某个接口就具有了对应的行为。抽象类主要用于代码复用，强调的是所属关系。
• 一个类只能继承一个类，但是可以实现多个接口。
• 接口中的成员变量只能是 public static final 类型的，不能被修改且必须有初始值，而抽象类的成员变量默认 default，可在子类中被重新定义，也可被重新赋值。

java 值传递与址（引用）传递

java中方法参数传递方式是本质上都是“值”传递

如果参数是基本类型（传“实际值”）：

由于栈中存的就是“实际值”（java基本类型的值存储在栈中，不在堆中），所以传递的是基本类型的“实际值”的拷贝。

 如果参数是引用类型（传“地址值”）：

由于栈中存的是地址（该地址指向堆内存中存储位置，即引用），所以传递的是“堆中的地址”的拷贝。所以我们说成是“引用（址）传递”。

注意：
1. “String和8大基本类型的包装类”是不可变类型，即特殊的引用类型，所以每次修改操作都是新创建的对象，栈中的地址不断更换，所以出现了不能修改值的效果，让大家误以为是值传递了。
2. 而一般对我们自己创建的类进行修改操作，就会顺着引用的地址“找到并修改掉”原来的值，所以达到了引用传递的效果。

如果是基本数据类型就不会改变，因为它只是复制（拷贝）了一份数据10给n2，并没有对自己产生任何影响和改变。因而说，基本数据类型的本质是值传递，或者说值拷贝。

但是这个数组就会改变。因为上面是将arr1的地址0x0011复制（拷贝）一份给arr2，并不是直接把值复制（拷贝）给arr2，所以它们共同指向了同一个地址，相当于一扇门有两把钥匙，这两把钥匙都可以打开这扇门。因而说，引用数据类型的本质是地址传递，或者说是地址拷贝。

案例1：传递基本类型参数

public static void main(String[] args) {
    int num1 = 10;
    int num2 = 20;
    swap(num1, num2);
    System.out.println("num1 = " + num1);
    System.out.println("num2 = " + num2);
}

public static void swap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;
    System.out.println("a = " + a);
    System.out.println("b = " + b);
}

a = 20
b = 10
num1 = 10
num2 = 20

解析：

在 swap() 方法中，a、b 的值进行交换，并不会影响到 num1、num2。因为，a、b 的值，只是从 num1、num2 的复制过来的。也就是说，a、b 相当于 num1、num2 的副本，副本的内容无论怎么修改，都不会影响到原件本身。

通过上面例子，我们已经知道了一个方法不能修改一个基本数据类型的参数，而对象引用作为参数就不一样，请看案例2。

案例2：传递引用类型参数1

	public static void main(String[] args) {
      int[] arr = { 1, 2, 3, 4, 5 };
      System.out.println(arr[0]);
      change(arr);
      System.out.println(arr[0]);
	}

	public static void change(int[] array) {
      // 将数组的第一个元素变为0
      array[0] = 0;
	}

//1,0

看了这个案例很多人肯定觉得 Java 对引用类型的参数采用的是引用传递。

实际上，并不是的，这里传递的还是值，不过，这个值是实参的地址罢了！

也就是说 change 方法的参数拷贝的是 arr （实参）的地址，因此，它和 arr 指向的是同一个数组对象。这也就说明了为什么方法内部对形参的修改会影响到实参。

案例3 ：传递引用类型参数2

public class Person {
    private String name;
   // 省略构造函数、Getter&Setter方法
}

public static void main(String[] args) {
    Person xiaoZhang = new Person("小张");
    Person xiaoLi = new Person("小李");
    swap(xiaoZhang, xiaoLi);
    System.out.println("xiaoZhang:" + xiaoZhang.getName());
    System.out.println("xiaoLi:" + xiaoLi.getName());
}

public static void swap(Person person1, Person person2) {
    Person temp = person1;
    person1 = person2;
    person2 = temp;
    System.out.println("person1:" + person1.getName());
    System.out.println("person2:" + person2.getName());
}

//person1:小李
//person2:小张
//xiaoZhang:小张
//xiaoLi:小李

 怎么回事？？？两个引用类型的形参互换并没有影响实参啊！

swap 方法的参数 person1 和 person2 只是拷贝的实参 xiaoZhang 和 xiaoLi 的地址。因此， person1 和 person2 的互换只是拷贝的两个地址的互换罢了，并不会影响到实参 xiaoZhang 和 xiaoLi 。

总结

Java 中将实参传递给方法（或函数）的方式是 值传递 ：

• 如果参数是基本类型的话，很简单，传递的就是基本类型的字面量值的拷贝，会创建副本。
• 如果参数是引用类型，传递的就是实参所引用的对象在堆中地址值的拷贝，同样也会创建副本。

String与8种基本数据类型的包装类

8种基本数据类型采用值传递，其包装类型与String与其他我们手写的类都是引用传递。只是由于String和8种包装类型都是不可变类，所以每次操作都是新创一个对象并重新赋给引用；在函数调用的时候，如果形参是String或者8种包装类型，操作形参不会影响实参，操作形参相当于重新创建对象不会影响原实参。

可变与不可变

不可变：
String与8种包装类型、BigInteger、BigDecimal是不可变类，不可变的意思是每次更换值都会重新生成对象并赋给引用。不用考虑线程安全。我们也可以设计自己的不可变类。

可变：
其他我们手写的实体类一般都是可变类。

String、StringBuffer、StringBuilder 的区别？

String 是不可变的（后面会详细分析原因）。

1. 保存字符串的数组被 final 修饰且为私有的，并且String 类没有提供/暴露修改这个字符串的方法。
2. String 类被 final 修饰导致其不能被继承，进而避免了子类破坏 String 不可变。

StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在 AbstractStringBuilder 中也是使用字符数组保存字符串，不过没有使用 final 和 private 关键字修饰，最关键的是这个 AbstractStringBuilder 类还提供了很多修改字符串的方法比如 append 方法。

1. 操作少量的数据: 适用 String
2. 单线程操作字符串缓冲区下操作大量数据: 适用 StringBuilder
3. 多线程操作字符串缓冲区下操作大量数据: 适用 StringBuffer

 final 在 Java 中有什么作用？

• final 修饰的类叫最终类，该类不能被继承。
• final 修饰的方法不能被重写。
• final 修饰的变量叫常量，常量必须初始化，初始化之后值就不能被修改。

---

异常与错误

Exception 和 Error 有什么区别？

在 Java 中，所有的异常都有一个共同的祖先 java.lang 包中的 Throwable 类。Throwable 类有两个重要的子类:

• Exception :程序本身可以处理的异常，可以通过 catch 来进行捕获。Exception 又可以分为 Checked Exception (受检查异常，必须处理) 和 Unchecked Exception (不受检查异常，可以不处理)。
• Error ：Error 属于程序无法处理的错误 ，我们没办法通过 catch 来进行捕获不建议通过catch捕获 。例如 Java 虚拟机运行错误（Virtual MachineError）、虚拟机内存不够错误(OutOfMemoryError)、类定义错误（NoClassDefFoundError）等 。这些异常发生时，Java 虚拟机（JVM）一般会选择线程终止。

Checked Exception 和 Unchecked Exception 有什么区别？

Checked Exception 即 受检查异常 ，Java 代码在编译过程中，如果受检查异常没有被 catch或者throws 关键字处理的话，就没办法通过编译。

Throwable 类常用方法有哪些？

• String getMessage(): 返回异常发生时的简要描述
• String toString(): 返回异常发生时的详细信息
• String getLocalizedMessage(): 返回异常对象的本地化信息。使用 Throwable 的子类覆盖这个方法，可以生成本地化信息。如果子类没有覆盖该方法，则该方法返回的信息与 getMessage()返回的结果相同
• void printStackTrace(): 在控制台上打印 Throwable 对象封装的异常信息

throw和throws的区别？

一、语法位置不同。throw用于函数内部，后面跟的是异常对象，而throws用于函数结尾，后面跟的是异常类，后面可以跟多个不同的异常类，表示抛出不同的异常

二、关键字功能不同。throw用于抛出异常，并将问题立即抛出给上一级的调用者，

并且当throw执行到时，后面的其他语句不会执行。而throws只是用于声明异常，让调用者知道这里可能会出现问题，并提前处理异常发生情况，属于一种提前通知。

相同点：那就是都是被动的方式（不主动处理）来处理异常，只是抛出异常，真正处理异常的往往是由调用他们的上层函数去捕获处理。

try-catch-finally 如何使用？

• try块 ： 用于捕获异常。其后可接零个或多个 catch 块，如果没有 catch 块，则必须跟一个 finally 块。
• catch块 ： 用于处理 try 捕获到的异常。
• finally 块 ： 无论是否捕获或处理异常，finally 块里的语句都会被执行。当在 try 块或 catch 块中遇到 return 语句时，finally 语句块将在方法返回之前被执行。

1. finally 之前虚拟机被终止运行的话，finally 中的代码就不会被执行。
2. 程序所在的线程死亡。
3. 关闭 CPU。

自定义异常类型

​ Java 的异常机制中所定义的所有异常不可能预见所有可能出现的错误，某些特定的情境下，则需要我们自定义异常类型来向上报告某些错误信息。

在 Java 中你可以自定义异常。编写自己的异常类时需要记住下面的几点。

• 所有异常都必须是 Throwable 的子类。
• 如果希望写一个检查性异常类，则需要继承 Exception 类。
• 如果你想写一个运行时异常类，那么需要继承 RuntimeException 类。

是自定义运行时异常：

public class ServiceException extends RuntimeException{
    // 错误码
    private Integer code;

    // 错误信息
    private String message;
    
    // 空构造
    public ServiceException(){}

    public ServiceException(String message, Integer code)
    {
        this.message = message;
        this.code = code;
    }

    public Integer getCode() {
        return code;
    }

    public void setCode(Integer code) {
        this.code = code;
    }

    @Override
    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }
}

在需要抛出这个异常的地方，我们可以这样：

throw new ServiceException(102,"业务出问题了");

面向对象

概念

类：不存在的，人类大脑思考总结一个模板（这个模板当中描述了共同特征。）

对象：实际存在的个体。 实例：对象还有另一个名字叫做实例。

实例化：通过类这个模板创建对象的过程，叫做：实例化。

抽象：多个对象具有共同特征，进行思考总结抽取共同特征的过程。

类 --【实例化】--> 对象(实例) ​

对象 --【抽象】--> 类

对象和引用的区别？

对象是通过new出来的，在堆内存中存储。 ​

引用是：但凡是变量，并且该变量中保存了内存地址指向了堆内存当中的对象的。

普通类和抽象类有哪些区别？

• 普通类不能包含抽象方法，抽象类可以包含抽象方法。
• 抽象类不能直接实例化，普通类可以直接实例化。

抽象类能使用 final 修饰吗？

不能，定义抽象类就是让其他类继承的，如果定义为 final 该类就不能被继承，这样彼此就会产生矛盾，所以 final 不能修饰抽象类。

接口和抽象类有什么区别？

• 实现：抽象类的子类使用 extends 来继承；接口必须使用 implements 来实现接口。
• 构造函数：抽象类可以有构造函数；接口不能有。
• 实现数量：类可以实现很多个接口；但是只能继承一个抽象类。
• 访问修饰符：接口中的方法默认使用 public 修饰；抽象类中的方法可以是任意访问修饰符。

静态方法和实例方法有何不同？

1. 在外部调用静态方法时，只能使用"类名.方法名"的方式，不能使用"对象名.方法名"的方式。而实例方法可以使用"对象名.方法名"的方式。也就是说，调用静态方法可以无需创建对象。
2. 静态方法在访问本类的成员时，只允许访问静态成员（即静态成员变量和静态方法），而不允许访问实例成员变量和实例方法；实例方法则无此限制

成员变量和静态变量和static

类变量==静态变量           实例变量实际上就是：对象级别的变量。

成员变量和类变量的区别

1、两个变量的生命周期不同

                成员变量随着对象的创建而存在，随着对象的回收而释放。

                静态变量随着类的加载而存在，随着类的消失而消失。

2、调用方式不同

                成员变量只能被对象调用。

                静态变量可以被对象调用，还可以被类名调用。

3、别名不同

                成员变量也称为实例变量。

                静态变量也称为类变量。

4、数据存储位置不同

                成员变量存储在堆内存的对象中，所以也叫对象的特有数据。

                静态变量数据存储在方法区（共享数据区）的静态区，所以也叫对象的共享数据。

static修饰成员方法

static修饰的方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。

并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都必须依赖具体的对象才能够被调用。

但是在非静态成员方法中是可以访问静态成员方法/变量的。

static修饰的统一都是静态的，都是类相关的，不需要new对象。直接采用“类名.”访问。

static修饰成员变量

static修饰的变量也称为静态变量，静态变量和非静态变量的区别是：静态变量被所有对象共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。（可以修改）==等于全局变量

static成员变量的初始化顺序按照定义的顺序进行初始化。

static修饰代码块

static关键字还有一个比较重要的作用就是用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来依次执行每个static块，并且只会执行一次。

static块可以优化程序性能，是因为它的特性：只会在类被初次加载的时候执行一次。(丢进内存)

优先级：父类静态代码块 > 子类静态代码块 > 父类构造代码块 > 父类构造方法 > 子类构造代码块 > 子类构造方法
静态执行一次!

import com.lgx.jdbc.TestJdbc;
//创建一个含有静态代码块、构造代码块和自己的构造方法（非继承父类）的类
public class TestStaticCoding {
    static {//静态代码块定义
        System.out.println("静态代码块");
    }
    {//构造代码块的创建
        System.out.println("构造代码块");
    }
    public TestStaticCoding(){//类的构造方法定义
        super();//先调用父类的构造方法
        System.out.println("构造方法");//在实例化自己的对象的时候，要做的事
    }
     public static void main(String[] args) throws ClassNotFoundException {
        Class.forName("com.study.staticcoding.TestStaticCoding");//这个时候类被加载，静态代码块被执行一次，类再进程中被加载过了，以后不会再加载了
 
        new TestStaticCoding();//创建一个类的对象，这个时候类早已被加载了，只会先执行构造代码块，再执行构造方法
        new TestStaticCoding();
    }
 
}

 执行的结果：

类加载时，执行静态代码块，类的对象创建时 ，先执行构造代码块，再执行构造方法

弊端

1、有些数据是对象特有的数据，是不可以被静态修饰的。因为那样的话，特有数据会变成对象的共享数据。这样对事物的描述就出了问题。所以，在定义静态时，必须要明确，这个数据是否是被对象所共享的。

2、静态方法只能访问静态成员，不可以访问非静态成员。因为静态方法加载时，优先于对象存在，所以没有办法访问对象中的成员。

3、静态方法中不能使用this，super关键字。因为this代表对象，而静态在时，有可能没有对象，所以this无法使用。

泛型

概念

Java泛型设计原则：只要在编译时期没有出现警告，那么运行时期就不会出现ClassCastException异常.

泛型：把类型明确的工作推迟到创建对象或调用方法的时候才去明确的特殊的类型

参数化类型:

• 把类型当作是参数一样传递

• <数据类型> 只能是引用类型

相关术语：

• ArrayList<E>中的E称为类型参数变量

• ArrayList<Integer>中的Integer称为实际类型参数

• 整个称为ArrayList<E>泛型类型

• 整个ArrayList<Integer>称为参数化的类型ParameterizedType

JDK8新特性：钻石表达式 List<String> list = new ArrayList<>(); 类型自动推断！

泛型的作用

• 代码更加简洁【不用强制转换】

• 程序更加健壮【只要编译时期没有警告，那么运行时期就不会出现ClassCastException异常】

• 可读性和稳定性【在编写集合的时候，就限定了类型】

早期Java是使用Object来代表任意类型的，但是向下转型有强转的问题，这样程序就不太安全

泛型后的遍历

在创建集合的时候，我们明确了集合的类型了，所以我们可以使用增强for来遍历集合！

    //创建集合对象
    ArrayList<String> list = new ArrayList<>();
​
    list.add("hello");
    list.add("world");
    list.add("java");
​
    //遍历,由于明确了类型.我们可以增强for
    for (String s : list) {
        System.out.println(s);
    }

泛型类

/*
    1:把泛型定义在类上
    2:类型变量定义在类上,方法中也可以使用
 */
public class ObjectTool<T> {
    private T obj;
​
    public T getObj() {
        return obj;
    }
​
    public void setObj(T obj) {
        this.obj = obj;
    }
}

用户想要使用哪种类型，就在创建的时候指定类型。使用的时候，该类就会自动转换成用户想要使用的类型了。

    public static void main(String[] args) {
        //创建对象并指定元素类型
        ObjectTool<String> tool = new ObjectTool<>();
​
        tool.setObj(new String("罗海江"));
        String s = tool.getObj();
        System.out.println(s);
​
​
        //创建对象并指定元素类型
        ObjectTool<Integer> objectTool = new ObjectTool<>();
        /**
         * 如果我在这个对象里传入的是String类型的,它在编译时期就通过不了了.
         */
        objectTool.setObj(10);
        int i = objectTool.getObj();
        System.out.println(i);
    }

泛型方法

• 定义泛型方法....泛型是先定义后使用的

    //定义泛型方法..
    public <T> void show(T t) {
        System.out.println(t);
    }
​
​
    public static void main(String[] args) {
        //创建对象
        ObjectTool tool = new ObjectTool();
​
        //调用方法,传入的参数是什么类型,返回值就是什么类型
        tool.show("hello");
        tool.show(12);
        tool.show(12.5);
​
    }

泛型类派生出的子类

泛型类是拥有泛型这个特性的类，它本质上还是一个Java类，那么它就可以被继承

那它是怎么被继承的呢？？这里分两种情况

子类明确泛型类的类型参数变量

/*
    把泛型定义在接口上
 */
interface Inter<T> {
    public abstract void show(T t);
​
}
​
​
/**
 * 子类明确泛型类的类型参数变量:
 */
​
class InterImpl implements Inter<String> {
    @Override
    public void show(String s) {
        System.out.println(s);
    }
}

子类不明确泛型类的类型参数变量

• 当子类不明确泛型类的类型参数变量时，外界使用子类的时候，也需要传递类型参数变量进来，在实现类上需要定义出类型参数变量

/*
    把泛型定义在接口上
 */
interface Inter<T> {
    public abstract void show(T t);
}
​
/**
 * 子类不明确泛型类的类型参数变量:
 *      实现类也要定义出<T>类型的
 *
 */
class InterImpl<T> implements Inter<T> {
    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

测试代码

    public static void main(String[] args) {
        //第一种情况测试
        Inter<String> i = new InterImpl();
        i.show("hello");
        //第二种情况测试
        Inter<String> ii = new InterImp2<>();
        ii.show("100");
    }

• 实现类的要是重写父类的方法，返回值的类型是要和父类一样的！

• 类上声明的泛形只对非静态成员有效

类型通配符

题目：接收一个集合参数，遍历集合并把集合元素打印出来，怎么办？

//出现警告，说没有确定集合元素的类型....这样是不优雅的...
    public void test(List list) {
        for (Object o : list) {
            System.out.println(o);
        }
    }
//下面都可以
    public void test1(List<Object> list){
        for (Object o : list) {
            System.out.println(o);
        }
    }
​
    public void test2(List<?> list){
        for (Object o : list) {
            System.out.println(o);
        }
    }