【Java】|【Java】 java基础和面向对象（回顾）【Java】java基础和面向对象（回

Java枚举 ava 5.0引入了枚举，枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的bug。

enum FreshJuiceSize { SMALL("small"), MEDIUM("medium"), LARGE("large"); FreshJuiceSize(String a) { this.a = a; } public String a() { return a + 1; } public String a; public static class A { } }

注意：枚举可以单独声明或者声明在类里面。方法、变量、构造函数也可以在枚举中定义。
Java 空行空白行，或者有注释的行，Java编译器都会忽略掉。
常用转义字符前面有反斜杠（\）的字符代表转义字符，它对编译器来说是有特殊含义的。
"\b" (退格) "\f" (换页) "\n" (换行) "\r" (回车) "\t" (水平制表符(到下一个tab位置)) "' " (单引号) "" " (双引号) "\" (反斜杠)
Linux中\n表示：回车+换行；
Windows中\r\n表示：回车+换行。
Mac中\r表示：回车+换行。
java的八种基本类型（按字节来分） boolean 布尔型 1个字节 8bit（8位）
byte 字节类型 1个字节
char 字符类型 2个字节
short 短整型 2个字节
int 整型 4个字节
float 浮点型（单精度）4个字节
long 长整型 8个字节
double 双精度类型 8个字节
Java中默认的整数类型是int，如果要定义为long ，则要在数值后加上L或者l
默认的浮点型是双精度浮点，如果要定义float，则要在数值后面加上f或者F
一个字节等于8位，1个字节等于256个数。2^8
一个英文字母或者阿拉伯数字占一个字节
一个汉字占2个字节
自动类型转换整型、实型（常量）、字符型数据可以混合运算。运算中，不同类型的数据先转化为同一类型，然后进行运算。转换从低级到高级。

不能对boolean类型进行类型转换。
不能把对象类型转换成不相关类的对象。
在把容量大的类型转换为容量小的类型时必须使用强制类型转换。
转换过程中可能导致溢出或损失精度
因为 byte 类型是 8 位，最大值为127，所以当 int 强制转换为 byte 类型时，值 128 时候就会导致溢出。
浮点数到整数的转换是通过舍弃小数得到，而不是四舍五入

java局部变量 Java 局部变量
局部变量声明在方法、构造方法或者语句块中；
局部变量在方法、构造方法、或者语句块被执行的时候创建，当它们执行完成后，变量将会被销毁；
访问修饰符不能用于局部变量；
局部变量只在声明它的方法、构造方法或者语句块中可见；
局部变量是在栈上分配的。
局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使用。
实例变量实例变量声明在一个类中，但在方法、构造方法和语句块之外；
当一个对象被实例化之后，每个实例变量的值就跟着确定；
实例变量在对象创建的时候创建，在对象被销毁的时候销毁；
实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方式获取实例变量信息；
实例变量可以声明在使用前或者使用后；
访问修饰符可以修饰实例变量；
实例变量对于类中的方法、构造方法或者语句块是可见的。一般情况下应该把实例变量设为私有。通过使用访问修饰符可以使实例变量对子类可见；
实例变量具有默认值。数值型变量的默认值是0，布尔型变量的默认值是false，引用类型变量的默认值是null。变量的值可以在声明时指定，也可以在构造方法中指定；
实例变量可以直接通过变量名访问。但在静态方法以及其他类中，就应该使用完全限定名：ObejectReference.VariableName。
抽象方法抽象方法不能被声明成 final 和 static。
任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
volatile 修饰符 volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
一个 volatile 对象引用可能是 null。
transient 修饰符 【【Java】|【Java】 java基础和面向对象（回顾）】序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。
该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。
static和final static不可以修饰外部类，可以修饰内部类，方法和全局变量
final可以修饰类，方法，变量（包括内部变量）。final 修饰属性，声明变量时可以不赋值，而且一旦赋值就不能被修改了。对 final 属性可以在三个地方赋值：声明时、初始化块中、构造方法中，总之一定要赋值。
final 变量：
final 变量能被显式地初始化并且只能初始化一次。被声明为 final 的对象的引用不能指向不同的对象。但是 final 对象里的数据可以被改变。也就是说 final 对象的引用不能改变，但是里面的值可以改变。
final 方法:
类中的 final 方法可以被子类继承，但是不能被子类修改。
final 类:
final 类不能被继承，没有类能够继承 final 类的任何特性。
自增自减运算符 1、自增（++）自减（--）运算符是一种特殊的算术运算符，在算术运算符中需要两个操作数来进行运算，而自增自减运算符是一个操作数。
2、前缀自增自减法(++a,--a): 先进行自增或者自减运算，再进行表达式运算。
3、后缀自增自减法(a++,a--): 先进行表达式运算，再进行自增或者自减运算
while 循环和do…while 循环对于 while 语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。do…while 循环和 while 循环相似，不同的是，do…while 循环至少会执行一次。
continue 关键字 continue 适用于任何循环控制结构中。作用是让程序立刻跳转到下一次循环的迭代。
在 for 循环中，continue 语句使程序立即跳转到更新语句。
在 while 或者 do…while 循环中，程序立即跳转到布尔表达式的判断语句。
if...else if...else 语句 if 语句后面可以跟 elseif…else 语句，这种语句可以检测到多种可能的情况。
使用 if，else if，else 语句的时候，需要注意下面几点：
if 语句至多有 1 个 else 语句，else 语句在所有的 elseif 语句之后。
if 语句可以有若干个 elseif 语句，它们必须在 else 语句之前。
一旦其中一个 else if 语句检测为 true，其他的 else if 以及 else 语句都将跳过执行。
switch 语句 switch 语句中的变量类型可以是：char,byte,short,int,Character,Byte,Short,Integer,String,enum
Integer 对于–128到127（默认是127）之间的值,被装箱后，会被放在内存里进行重用,但是如果超出了这个值,系统会重新new 一个对象

Integer a = 10; Integer b = 10; System.out.println(a == b); // true System.out.println(a.equals(b)); // true Integer a = 1000; Integer b = 1000; System.out.println(a == b); // false System.out.println(a.equals(b)); // true

Math类的个别方法 ceil()：返回大于等于( >= )给定参数的的最小整数。
floor()：返回小于等于（<=）给定参数的最大整数。
rint()：返回与参数最接近的整数。返回类型为double。
round()：它表示四舍五入，算法为 Math.floor(x+0.5)，即将原来的数字加上 0.5 后再向下取整，所以，Math.round(11.5) 的结果为12，Math.round(-11.5) 的结果为-11。
String :String 类是不可改变的，所以你一旦创建了 String 对象，那它的值就无法改变了。如果需要对字符串做很多修改，那么应该选择使用 StringBuffer & StringBuilder 类。

String 类是不可改变的解析，例如： String s = "Google"; System.out.println("s = " + s); s = "Runoob"; System.out.println("s = " + s); 输出结果为： Google Runoob

从结果上看是改变了，但为什么门说String对象是不可变的呢？
原因在于实例中的 s 只是一个 String 对象的引用，并不是对象本身，当执行 s = "Runoob"; 创建了一个新的对象 "Runoob"，而原来的 "Google" 还存在于内存中。

文章图片
image.png Java StringBuffer 和 StringBuilder 类当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。
和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。
StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。
由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。
Arrays 类 java.util.Arrays 类能方便地操作数组，它提供的所有方法都是静态的。
具有以下功能：
给数组赋值：通过 fill 方法。
对数组排序：通过 sort 方法,按升序。
比较数组：通过 equals 方法比较数组中元素值是否相等。
查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。
使用printf格式化日期 printf 方法可以很轻松地格式化时间和日期。使用两个字母格式，它以 %t 开头并且以下面表格中的一个字母结尾。

import java.util.Date; public class DateDemo { public static void main(String args[]) { // 初始化 Date 对象 Date date = new Date(); //c的使用 System.out.printf("全部日期和时间信息：%tc%n",date); //f的使用 System.out.printf("年-月-日格式：%tF%n",date); //d的使用 System.out.printf("月/日/年格式：%tD%n",date); //r的使用 System.out.printf("HH:MM:SS PM格式（12时制）：%tr%n",date); //t的使用 System.out.printf("HH:MM:SS格式（24时制）：%tT%n",date); //R的使用 System.out.printf("HH:MM格式（24时制）：%tR",date); } }

可变参数 JDK 1.5 开始，Java支持传递同类型的可变参数给一个方法。
方法的可变参数的声明如下所示：
typeName... parameterName
在方法声明中，在指定参数类型后加一个省略号(...) 。
一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

public static void printMax( double... numbers) { if (numbers.length == 0) { System.out.println("No argument passed"); return; } double result = numbers[0]; for (int i = 1; i result) { result = numbers[i]; } } System.out.println("The max value is " + result); }

finalize() 方法 Java 允许定义这样的方法，它在对象被垃圾收集器析构(回收)之前调用，这个方法叫做 finalize( )，它用来清除回收对象。
例如，你可以使用 finalize() 来确保一个对象打开的文件被关闭了。
在 finalize() 方法里，你必须指定在对象销毁时候要执行的操作。
finalize() 一般格式是：

protected void finalize() { // 在这里终结代码 }

关键字 protected 是一个限定符，它确保 finalize() 方法不会被该类以外的代码调用。
当然，Java 的内存回收可以由 JVM 来自动完成。如果你手动使用，则可以使用上面的方法。

注：当我们调用System.gc()的时候，其实并不会马上进行垃圾回收，甚至不一定会执行垃圾回收。查看ZygoteInit.java 里面 gc()和runFinalizationSync()是配合使用才有效果

java流

文章图片
image.png throw与throws的比较 1、throws出现在方法函数头；而throw出现在函数体。
2、throws表示出现异常的一种可能性，并不一定会发生这些异常；throw则是抛出了异常，执行throw则一定抛出了某种异常对象。
3、两者都是消极处理异常的方式（这里的消极并不是说这种方式不好），只是抛出或者可能抛出异常，但是不会由函数去处理异常，真正的处理异常由函数的上层调用处理。
try/catch/finally catch 不能独立于 try 存在。
在 try/catch 后面添加 finally 块并非强制性要求的。
try 代码后不能既没 catch 块也没 finally 块。
try, catch, finally 块之间不能添加任何代码。

try{ //待捕获代码 }catch（Exception e）{ System.out.println("catch is begin"); return 1 ； }finally{ System.out.println("finally is begin"); } //运行结果如下： catch is begin finally is begin

也就是说会先执行catch里面的代码后执行finally里面的代码最后才return1 ；再看如下代码：

try{ //待捕获代码 }catch（Exception e）{ System.out.println("catch is begin"); return 1 ； }finally{ System.out.println("finally is begin"); return 2 ; }

这段代码中输出结果跟上段是一样的，然而返回的是return 2 ；原因很明显，就是执行了finally后已经return了，所以catch里面的return不会被执行到。也就是说finally永远都会在catch的return前被执行。catch和finally中的system.out都会输出，但是catch中的system.out优先于finally的system.out输出。
通用异常 JVM(Java虚拟机) 异常：由 JVM 抛出的异常或错误。例如：NullPointerException 类，ArrayIndexOutOfBoundsException 类，ClassCastException 类。

程序级异常：由程序或者API程序抛出的异常。例如 IllegalArgumentException 类，IllegalStateException 类。

文章图片
image.png 继承利用继承的方法，可以重用已存在类的方法和属性，而不用重写这些代码。
子类可以继承父类的静态方法，子类不可以复写父类的静态方法和final修饰的方法
子类拥有父类非private的属性，方法。
子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
子类可以用自己的方式实现父类的方法。
Java的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如A类继承B类，B类继承C类，所以按照关系就是C类是B类的父类，B类是A类的父类，这是java继承区别于C++继承的一个特性。
提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系）。
super 与 this 关键字 super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。静态方法中不能使用 super 关键字。super 语句必须是子类构造方法的第一条语句。如果是继承的方法，是没有必要使用 super 来调用，直接即可调用。但如果子类覆盖或重写了父类的方法，则只有使用 super 才能在子类中调用父类中的被重写的方法。
this关键字：指向自己的引用。用当前类的构造方法，并且必须是方法的第一条语句。如：this(); 调用默认构造方法。this(参数); 调用带参构造方法。限定当前对象的数据域变量。一般用于方法内的局部变量与对象的数据域变量同名的情况。如 this.num = num。this.num 表示当前对象的数据域变量 num，而 num 表示方法中的局部变量。
构造器子类不能继承父类的构造器（构造方法或者构造函数），但是父类的构造器带有参数的，则必须在子类的构造器中显式地通过super关键字调用父类的构造器并配以适当的参数列表。
如果父类有无参构造器，则在子类的构造器中用super调用父类构造器不是必须的，如果没有使用super关键字，系统会自动调用父类的无参构造器。
方法的重写规则参数列表必须完全与被重写方法的相同；
返回类型必须完全与被重写方法的返回类型相同；
访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为public，那么在子类中重写该方法就不能声明为protected。
父类的成员方法只能被它的子类重写。
声明为final的方法不能被重写。
声明为static的方法不能被重写，但是能够被再次声明。
子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
构造方法不能被重写。
如果不能继承一个方法，则不能重写这个方法。
方法重载最常用的地方就是构造器的重载。
被重载的方法必须改变参数列表(参数个数或类型或顺序不一样)；
被重载的方法可以改变返回类型；
被重载的方法可以改变访问修饰符；
被重载的方法可以声明新的或更广的检查异常；
方法能够在同一个类中或者在一个子类中被重载。
无法以返回值类型作为重载函数的区分标准。
重载和重写的区别

文章图片
image.png java多态必要条件：继承、重写、父类引用指向子类对象
多态的优点：1. 消除类型之间的耦合关系 2. 可替换性 3. 可扩充性 4. 接口性 5. 灵活性 6. 简化性
虚方法：多态是父类引用指向子类对象，所以在编译的时候，编译器使用父类中的方法验证该语句，如果父类没有此方法则编译不通过，但是在运行的时候，Java虚拟机(JVM)调用的是子类中的方法。

class Animal{ public int age; public void move(){ System.out.println("动物可以移动"); } } class Dog extends Animal{ public double age; public void move(){ age = 10.00; System.out.println("狗可以跑和走"); } public void bark(){ System.out.println("狗可以吠叫"); } }class Cat extends Animal{ public void move(){ super.age = 3; System.out.println("猫可以跳"); } } public class TestOverride{ public static void main(String args[]){ Animal a = new Animal(); // Animal 对象 Animal b = new Dog(); // Dog 对象 Dog c = new Dog(); Cat d = new Cat(); a.move(); // 执行 Animal 类的方法 b.move(); //执行 Dog 类的方法 c.move(); //执行 Dog 类的方法 d.move(); //执行 Cat 类的方法 Object aValue = https://www.it610.com/article/a.age; Object bValue = b.age; Object cValue = c.age; System.out.println("The type of "+a.age+" is "+(aValue instanceof Double ? "double" : (aValue instanceof Integer ? "int" : ""))); System.out.println("The type of "+b.age+" is "+(bValue instanceof Double ? "double" : (bValue instanceof Integer ? "int" : ""))); System.out.println("The type of "+c.age+" is "+(cValue instanceof Double ? "double" : (cValue instanceof Integer ? "int" : ""))); // 覆盖age属性 System.out.println("The age of catis "+d.age); } }//结果 //动物可以移动 //狗可以跑和走 //狗可以跑和走 //猫可以跳 //The type of 0 is int //The type of 0 is int //The type of 10.0 is double //The age of catis 3

java抽象类由于抽象类不能实例化对象，所以抽象类必须被继承，才能被使用。也是因为这个原因，通常在设计阶段决定要不要设计抽象类。（代码表现形式上看没有抽象方法的抽象类是不可以new出来的。带有抽象方法的抽象类new出来的时候要实现抽象方法）
java封装封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。
适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。
优点：1. 良好的封装能够减少耦合。 2. 类内部的结构可以自由修改。 3. 可以对成员变量进行更精确的控制。 4. 隐藏信息，实现细节。
接口接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。
一个接口能继承另一个接口，这和类之间的继承比较相似。
在 JDK1.8，允许我们给接口添加两种非抽象的方法实现：
1、默认方法，添加 default 修饰即可；
2、静态方法，使用 static 修饰；示例如下：

interface Test{ //这个是默认方法 default String get(String aa){ System.out.println("我是jdk1.8默认实现方法..."); return ""; } //这个是静态方法 static void staticmethod(){ System.out.println("我是静态方法"); } }

接口和类的区别：1.接口不能用于实例化对象。 2.接口没有构造方法。 3.接口中所有的方法必须是抽象方法。 4.接口不能包含成员变量，除了 static 和 final 变量。 5.接口不是被类继承了，而是要被类实现。 6.接口支持多继承。
接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
接口的多继承在Java中，类的多继承是不合法，但接口允许多继承，。
在接口的多继承中extends关键字只需要使用一次，在其后跟着继承接口。如下所示：

public interface Impl2 extends Impl1,Impl {}

标记接口最常用的继承接口是没有包含任何方法的接口。
标记接口是没有任何方法和属性的接口.它仅仅表明它的类属于一个特定的类型,供其他代码来测试允许做一些事情。
标记接口作用：简单形象的说就是给某个对象打个标（盖个戳），使对象拥有某个或某些特权。
例如：java.awt.event 包中的 MouseListener 接口继承的 java.util.EventListener 接口定义如下：

package java.util; public interface EventListener{}

package（包）如果在一个包中，一个类想要使用本包中的另一个类，那么该包名可以省略。
JVM加载class文件的原理机制 JVM中类的装载是由类加载器（ClassLoader）和它的子类来实现的，Java中的类加载器是一个重要的Java运行时系统组件，它负责在运行时查找和装入类文件中的类。
由于Java的跨平台性，经过编译的Java源程序并不是一个可执行程序，而是一个或多个类文件。当Java程序需要使用某个类时，JVM会确保这个类已经被加载、连接（验证、准备和解析）和初始化。类的加载是指把类的.class文件中的数据读入到内存中，通常是创建一个字节数组读入.class文件，然后产生与所加载类对应的Class对象。加载完成后，Class对象还不完整，所以此时的类还不可用。当类被加载后就进入连接阶段，这一阶段包括验证、准备（为静态变量分配内存并设置默认的初始值）和解析（将符号引用替换为直接引用）三个步骤。最后JVM对类进行初始化，包括：1)如果类存在直接的父类并且这个类还没有被初始化，那么就先初始化父类；2)如果类中存在初始化语句，就依次执行这些初始化语句。
类的加载是由类加载器完成的，类加载器包括：根加载器（BootStrap）、扩展加载器（Extension）、系统加载器（System）和用户自定义类加载器（java.lang.ClassLoader的子类）。从Java 2（JDK 1.2）开始，类加载过程采取了父亲委托机制（PDM）。PDM更好的保证了Java平台的安全性，在该机制中，JVM自带的Bootstrap是根加载器，其他的加载器都有且仅有一个父类加载器。类的加载首先请求父类加载器加载，父类加载器无能为力时才由其子类加载器自行加载。JVM不会向Java程序提供对Bootstrap的引用。
Java泛型：https://www.jianshu.com/p/c6321a76fb8a
后续会整理一些java高级的部分！
错误不足之处或相关建议欢迎大家评论指出，谢谢！如果觉得内容可以的话麻烦喜欢（?）一下