面向对象之JAVA随记

匿名对象的使用

（1）理解：创建的对象，没有显式的赋给一个变量名，即为匿名对象。
（2）特征：匿名对象只能调用一次。

调用方法的三种方法

第一种：通过对象名.方法名进行调用，这是最普通的也是最常见的一种调用方式。
第二种：通过new关键字调用构造方法，这种是在实例化对象时使用的方式。
第三种：通过类名.方法名调用，当需要调用的那个方法为静态（有static的）方法时使用。

Eclipse中的快捷键

1.补全代码的声明:alt +/
2.快速修复，自动调包:ctrl + 1
3.批量导包:ctrl +shift +o
4.使用单行注释:ctrl +l
5.使用多行注释:ctrl + shift +/
6.取消多行注释:ctrl + shift +
7.复制指定行的代码: ctrl + alt + down或ctrl +alt+up
8.删除指定行的代码:ctrl + d
9.上下移动代码:alt + up或alt +down
10.切换到下一行代码空位: shift + enter
11.切换到上一行代码空位:ctrl + shift + enter
12.如何查看源码:ctrl +选中指定的结构或ctrl + shift +t
13.退回到前一个编辑的页面:alt + left
14.进入到下一个编辑的页面(针对于上面那条来说的)t+ right15.光标选中指定的类，查看继承树结构:ctrl + t
15、格式化代码:ctrl + shift +f
16、选中数行，整体往后移动: tab
17、选中数行，整体往前移动: shift + tab
18、在当前类中，显示类结构，并支持搜索指定的方法、属性等:ctrl +o
19、批量修改指定的变量名、方法名、类名等:alt +shift + r
20、选中的结构的大小写的切换:变成大写:ctrl +shift + ×
选中的结构的大小写的切换:变成小写:ctrl + shift +y
21、调出生成getter/ setter/构造器等结构: alt + shift + s
22、显示当前选择资源(工程or文件)的属性:alt +enter
23、快速查找:参照选中的word快速定位到下一个:ctrl + k

继承

(1)体现:一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。
特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只有因为封装性的影响，使得子类不能直接调用父类的结构而已。
(2)如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.object类
(3)所有的java类（除java.lang.0bject类之外）都直接或间接的继承于java.lang.0bject类,意味着，所有的java类具有java.lang.object类声明的功能。
(4)子类继承的方法只能操作子类继承和隐藏的成员变量。

重写

方法的声明:权限修饰符返回值类型方法名(形参列表) throws异常的类型{
//方法体
}
约定俗称:子类中的叫重写的方法,父类中的叫被重写的方法
（1） 子类重写的方法的方法名和形参列表与父类被重写的方法的方法名和形参列表相同
（2） 子类重写的方法的权限修饰符不小于父类被重写的方法的权限修饰符
>特殊情况:子类不能重写父类中声明为private权限的方法
（3）返回值类型:
>父类被重写的方法的返回值类型是void，则子类重写的方法的返回值类型只能是void
>父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类
>父类被重写的方法的返回值类型是基本数据类型(比如: double)，则子类重写的方法的返回值类型必须是相同的基本数据类型（必须也是double）。
（4）子类重写的方法抛出的异常类型不大于父类被重写的方法抛出的异常类型
（5）子类和父类中的同名同参数的方法要么都声明为非static的（考虑重写），要么都声明为static的(不是重写)。

多态

（1）理解多态性:可以理解为一个事物的多种形态。
（2）何为多态性:
对象的多态性:父类的引用指向子类的对象（或子类的对象赋给父类的引用)
（3）多态的使用:虚拟方法调用
有了对象的多态性以后，我们在编译期，只能调用父类中声明的方法，但在运行期，我们实际执行的是子类重写父类的方法。总结:编译，看左边;运行,看右边。
（4）多态性的使用前提:类的继承关系②方法的重写
（5）对象的多态性，只适用于方法，不适用于属性（编译和运行都看左边)
36、instanceof关键字的使用
a instanceof A:判断对象a是否是类A的实例。如果是，返回true;如果不是，返回false。
使用情境:为了避免在向下转型时出现ClassCastException的异常，我们在向下转型之前，先进行instanceof的判断，一旦返回true，就进行向下转型。如果返回false，不进行向下转型。
如果a instanceof A返回true,则 a instanceof B也返回true，其中，类B是类A的父类。

super关键字的使用

1.super理解为:父类的
2.super可以用来调用:属性、方法、构造器
3.super的使用:调用属性和方法
3.1我们可以在子类的方法或构造器中。通过使用"super.属性“或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略"super . "
3.2特殊情况:当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。
3.3特殊情况:当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式,表明调用的是父类中被重写的方法。
4.super调用构造器
4.1我们可以在子类的构造器中显式的使用"super(形参列表)"的方式，调用父类中声明的指定的构造器
4.2 "super(形参列表)"的使用，必须声明在子类构造器的首行!
4.3我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)“只能二选一，不能同时出现
4.4在构造器的首行，没有显式的声明"this(形参列表)“或"super(形参列表)”，则默认调用的是父类中空参的构造器
4.5在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)”，调用父类中的构造器

object类中equals()方法的使用

1．是一个方法，而非运算符
2．只能适用于引用数据类型
3. object类中equals()的定义:
public boolean equals (Object obi) i
return (this == obj);
}
说明:Object类中定义的equals()和==的作用是相同的:比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体；
4、像String、Date、 File、包装类等都重写了0bject类中的equals()方法。重写以后，比较的不是两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。

object类中toString()的使用

1．当我们输出一个对象的引用时，实际上就是调用当前对象的toString()
2. object类中toString()的定义:
public String toString() {
return getclass( ).getName() +“@" + Integer.toHexString ( hashCode());}
3．像String、Date、File、包装类等都重写了0bject类中的toString()方法。使得在调用对象的toString()时，返回"实体内容"信息
4．自定义类也可以重写toString()方法，当调用此方法时，返回对象的"实体内容"

static关键字的使用

1.static:静态的
2.static可以用来修饰:属性、方法、代码块、内部类
3.使用static修饰属性:静态变量（或类变量)
3.1属性，按是否使用static修饰，又分为:静态属性vs非静态属性(实例变量)
实例变量:我们创建了类的多个对象，每个对象都独立的拥有一套类中的非静态属性。当修改其中一个对象中的非静态属性时，不会导致其他对象中同样的属性值的修改；
静态变量:我们创建了类的多个对象，多个对象共享同一个静态变量，当通过某一个对象修改静态变量时，会导致其他对象调用此静态变量时，是修改过了的。
3.2 static修饰属性的其他说明:
静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用静态变量的加载要早于对象的创建。
由于类只会加载一次，则静态变量在内存中也只会存在一份:存在方法区的静态域中。
4.使用static修饰方法:静态方法
随着类的加载而加载，可以通过"类.静态方法"的方式进行调用
静态方法中,只能调用静态的方法或属性
非静态方法中，既可以调用非静态的方法或属性，也可以调用静态的方法或属性
5. static注意点:
5.1 在静态的方法内，不能使用this关键字、super关键字
5.2 关于静态属性和静态方法的使用，大家都从生命周期的角度去理解

final关键字

1. final可以用来修饰的结构:类、方法、变量；
2. final用来修饰一个类:此类不能被其他类所继承，比如:String类、System类、StringBuffer类
   3.final 用来修饰方法:表明此方法不可以被重写，比如:Object类中getClass();
   4.final用来修饰变量:此时的"变量"就称为是一个常量
   4.1 final修饰属性:可以考虑赋值的位置有:显式初始化、代码块中初始化、构造器中初始化
   4.2 final修饰局部变量;
   尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。
   static final用来修饰属性:全局常量

abstract关键字的使用

1.abstract:抽象的
2.abstract可以用来修饰的结构:类、方法
3. abstract修饰类:抽象类
>此类不能实例化
>抽象类中一定有构造器，便于子类实例化时调用（涉及:子类对象实例化的全过程)>开发中，都会提供抽象类的子类,让子类对象实例化，完成相关的操作
4. abstract修饰方法:抽象方法
>抽象方法只有方法的声明，没有方法体
>包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法的。
>若子类重写了父类中的所有的抽象方法后，此子类方可实例化
>若子类没有重写父类中的所有的抽象方法，则此子类也是一个抽象类,需要使用abstract修饰
5.abstract使用上的注意点:
1.abstract不能用来修饰:属性、构造器等结构
2.abstract不能用来修饰私有方法、静态方法、final的方法、final的类

接口的使用

1.接口使用interface来定义
2.Java中,接口和类是并列的两个结构
3.如何定义接口:定义接口中的成员
3.1 JDK7及以前:只能定义全局常量和抽象方法
>全局常量:public static final的.但是书写时，可以省略不写
>抽象方法:public abstract的
3.2 JDK8:除了定义全局常量和抽象方法之外，还可以定义静态方法、默认方法(略)
4．接口中不能定义构造器的!意味着接口不可以实例化
5.Java开发中，接口通过让类去实现(implements)的方式来使用。
如果实现类覆盖了接口中的所有抽象方法，则此实现类就可以实例化
如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
5.Java类可以实现多个接口—>弥补了Java单继承性的局限性
格式:class AA extends BB implements CC,DD,EE
6．接口与接口之间可以继承，而且可以多继承

异常

一、异常的处理:抓抛模型
过程一:“抛”:程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象，并将此对象抛出，一旦抛出对象以后，其后的代码就不再执行。
过程二:“抓":可以理解为异常的处理方式:1 try-catch-finall 2 throws
二、try-catch-finally的使用

try{
//可能出现异常的代码
}catch(异常类型1变量名1){
//处理异常的方式1
}catch(异常类型2变量名2){
//处理异常的方式2
}catch(异常类型3变量名3){
//处理异常的方式3
}
……
finally{
		//一定会执行的代码
}

说明:
1.finally是可选的。
2．使用try将可能出现异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去catch中进行匹配
3．一旦try中的异常对象匹配到某一个catch时，就进入catch中进行异常的处理。一旦处理完成，就跳出当前的try-catch结构（在没有写finally的情况）。继续执行其后的代码
4. catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓。
catch中的异常类型如果满足子父类关系，则要求子类一定声明在父类的上面。否则，报错
5．常用的异常对象处理的方式:String getMessage() printStackTrace()
6．在try结构中声明的变量，再出了try结构以后，就不能再被调用
7、体会2:开发中，由于运行时异常比较常见，所以我们通常就不针对运行时异常编写try-catch-finally了。针对于编译时异常,一定要考虑异常的处理。
三、异常处理的方式二:throws +异常类型
1."throws +异常类型"写在方法的声明处。指明此方法执行时，可能会抛出的异常类型。
一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常类型时，就会被抛出。异常代码后续的代码，就不再执行!
2．体会: try-catch-finally:真正的将异常给处理掉了。
throws的方式只是将异常抛给了方法的调用者。并没有真正将异常处理掉。
四、如何自定义异常类?
1．继承于现有的异常结构:RuntimeException . Exception
2．提供全局常量: serialVersionUID
3．提供重载的构造器

public class MyException extends Exception{

public MyException(//可以有参数){
//该写啥写啥
}
//再写个具体的方法
}

一个小经验

出现这种问题，多半是前面的方法最后少了个 }

多线程

一、多线程的创建，方式一:继承于Thread类
1.创建一个继承于Thread类的子类
2．重写Thread类的run() -->将此线程执行的操作声明在run()中
3.创建Thread类的子类的对象
4．通过此对象调用start()
二、注意
1、不能通过直接调用run()的方式启动线程；
2、再启动一个线程，不可以还让已经start()的线程去执行，会IllegalThreadStateException,需要重新创建一个线程的对象
三、Thread中的常用方法:
1. start():启动当前线程;调用当前线程的run()
2. run():通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中3. currentThread():静态方法，返回执行当前代码的线程
4. getName():获取当前线程的名字
5. setName():设置当前线程的名字
6. yield()∶释放当前cpu的执行权
7. join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程才结束阻塞状态。
8. stop():已过时。当执行此方法时，强制结束当前线程。
9. sleep(Long milLitime):让当前线程*睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
10. isAlive():判断当前线程是否存活
四、线程的优先级:
1.MAX_PRIORITY: 10
MIN_PRIORITY: 1
NORM_PRIORITY: 5–>默认优先级
2.如何获取和设置当前线程的优先级:getPriority()∶获取线程的优先级
setpriority( int p)∶设置线程的优先级
说明:高优先级的线程要抢占低优先级线程cpu的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。
五、创建多线程的方式二:实现Runnable接口
1．创建一个实现了Runnable接口的类
2．实现类去实现Runnable中的抽象方法: run()
3．创建实现类的对象
4．将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5．通过Thread类的对象调用start()
六、在Java中，通过同步机制，来解决线程的安全问题。
方式一:同步代码块
synchronized(同步监视器){
/需要被同步的代码
}
说明:
1.操作共享数据的代码，即为需要被同步的代码
2.共享数据:多个线程共同操作的变量。比如: ticket就是共享数据。
3.同步监视器，俗称:锁。任何一个类的对象，都可以充当锁。
要求:多个线程必须要共用同一把锁。
4、在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
方式二:同步方法
5、在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器
6、关于同步方法的总结:
1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
2. 非静态的同步方法，同步监视器是: this
静态的同步方法，同步监视器是:当前类本身

注解

1、Annocation的使用示例
示例一:生成文档相关的注解
示例二:在编译时进行格式检查(JDK内置的三个基本注解)
@Override:限定重写父类方法，该注解只能用于方法
@Deprecated:用于表示所修饰的元素(类，方法等)已过时。
@Suppresswarnings:抑制编译器警告
2、如何自定义注解:参照@Suppresswarnings定义
注解声明为:@interface
②内部定义成员，通常使用vaLue表示
可以指定成员的默认值，使用default定义
如果自定义注解没有成员，表明是一个标识作用。
3、jdk提供的4种元注解
元注解:对现有的注解进行解释说明的注解
Retention:指定所修饰的 Annotation 的生命周期: SOURCE\CLASS(默认行为）\RUNTIME
只有声明为RUNTIME生命周期的注解，才能通过反射获取。
Target:用于指定被修饰的Annotation能用于修饰哪些程序元素。
出现的频率较低
Documented:表示所修饰的注解在被javadoc解析时，保留下来。
Inherited:被它修饰的 Annotation将具有继承性。

集合框架

/----collection接口:单列集合，用来存储一个一个的对象
/----List接口:存储有序的、可重复的数据。 -->“动态”数组
/----ArrayList、 LinkedList、 Vector
/----Set接口:存储无序的、不可重复的数据–>高中讲的"集合”
/----HashSet、 LinkedHashSet、 Treeset
/----Map接口:双列集合，用来存储一对(key - value)一对的数据–>高中函数: y = f(×)
/----HashMap、LinkedHashMap、TreeMap、HashtabLe、Properties
collection接口的常用方法
1、添加
add(Object obj)
addAIl(Collection coll)
2、获取有效元素的个数int size()
3、清空集合void clear()
4、是否是空集合boolean isEmpty()
5、是否包含某个元素
boolean contains(Object obj):是通过元素的equals方法来判断是否是同一个对象
boolean containsAll(Collection c):也是调用元素的equals方法来比较的。拿两个集合的元素挨个比较。
6、remove(0bject obj):从当前集合中移除obj元素。
7、removeAll(Collection coll1):差集:从当前集合中移除coll1中所有的元素。