final修饰的类不能被继承
final修饰的方法不能被覆盖
final修饰的变量是常量，只能赋值一次
覆盖注意事项：
1. 子类方法覆盖父类方法时，子类方法的权限要>=父类
2. 静态方法只能覆盖静态方法
3. 如果父类方法添加final, 则子类重新定义此方法会编译出错
4.在子类方法中可以通过super.method 调用父类方法，当然如果父类方法是private，也是不能调用的（实际上是子类重新定义method，并没
有覆盖父类method，可以认为父类method被隐藏了）
static
- 用于修饰成员（成员变量和成员函数），被修饰后的成员具备以下特点：
- 随着类的加载而加载，随着类的消失而消失
- 优先于对象而存在
- 被所有对象所共享
- 可以直接用类名调用如类名.成员
- 用于修饰静态代码块： static {...}
- 随着类的加载而执行，而且只执行一次，可以用于给类进行初始化
- 注：构造代码块{...}随着对象的构造而执行，而且创建几次就执行几次，可以用于给所有对象进行初始化
- 静态代码块-->构造函数{super()-->成员初始化-->构造代码块-->后续语句}
- 使用注意：
- 静态方法只能访问静态成员
- 静态方法中不可以出现this, super等关键字
- 主函数是静态的
- this & super
- this代表本类对象的引用
- super代表一个父类空间
- 当本类的成员和局部变量同名用this区分
- 当子父类的成员变量同名用super区分父类
interface
当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是接口interface.
对于接口中的常见成员都有固定的修饰符。
全局常量: public static final
抽象方法： public abstract
类与类之间是继承extends关系；类与接口之间是实现implements关系；接口与接口之间是继承关系，而且接口可以多继承
类可以在继承一个类的同时实现多个接口
抽象类的继承，是is a关系，在定义该体系的基本共性内容，接口的实现是like a关系，在定义体系额外功能
接口类型的引用，用于指向接口的子类对象
2.继承：
在子类的构造函数中第一行有一个默认的隐式语句 super(); 子类中所有的构造函数默认都会访问父类中的空参数的构造函
数。如果父类中没有定义空参数构造函数，那么子类的构造函数必须用super(...)明确要调用父类中哪个构造函数。同时子类构造函数中如果使用this调用了本类构造函数时，那么super语句就没有了，因为super和this都只能定义在第一行，所有只能有一个。
但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数。
3.多态：
成员变量：
编译时：参考引用型变量所属的类中是否有调用的成员变量，如果没有则编译失败
运行时：参考引用型变量所属的类中是否有调用的成员变量，并运行该所属类中的成员变量
成员函数：
编译时：参考引用类型变量所属的类中是否有调用的函数，如果没有则编译失败
运行时：参考的是对象所属的类中是否有调用的函数
静态函数：
编译时：参考引用类型变量所属的类中是否有调用的静态方法
运行时：参考引用类型变量所属的类中是否有调用的静态方法
其实对于静态方法，是不需要对象的，直接用类名调用
4.内部类：
内部类可以直接访问外部类中的成员
外部类要访问内部类，必须建立内部类的对象
// 直接访问外部类中的内部类中的成员
outer.inner in = new outer().new inner();
in.show();
// 如果内部类是静态的，相当于一个外部类
outer.inner in = new outer.inner();
in.show();
outer.inner.function();
// 如果内部类中定义了静态成员，该内部类必须也是静态的
Java Code
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
|
class Outer
{
int num = 3;
class Inner
{
int num = 4;
void show()
{
int num = 5;
System.out.println(Outer.this.num);
}
}
void method()
{
new Inner().show();
}
}
|
局部内部类
内部类可以放在局部位置上
内部类在局部位置上只能访问局部中被final修饰的局部变量
匿名内部类
前提：内部类必须继承或者实现一个外部类或者接口。
匿名内部类其实就是一个匿名子类对象。
格式：new 父类or接口(){子类内容}
Java Code
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
|
abstract class Demo
{
abstract void show();
}
class Outer
{
int num = 4;
/*
class Inner extends Demo
{
void show()
{
System.out.println("show ..."+num);
}
}
*/
public void method()
{
//new Inner().show();
/* Demo de = */ new Demo()//匿名内部类。
{
void show()
{
System.out.println("show ........" + num);
}
} .show();
// de.show();
}
}
class InnerClassDemo4
{
public static void main(String[] args)
{
new Outer().method();
}
}
|
注意：如下做法是错误的
Java Code
|
1
2
3
4
5
6
7
8
9
|
|
Object obj = new Object()
{
public void show()
{
System.out.println( "show run");
}
};
obj.show(); |
因为匿名内部类这个子类对象被向上转型为了Object类型，而Object类并没有show()的实现
通常的使用场景之一：
当函数参数是接口类型时，而且接口中的方法不超过三个，可以用匿名内部类作为实际参数进行传递
Java Code
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
|
|
interface Inter
{
void show1();
void show2();
}
class InnerClassDemo5
{
public static void main(String[] args)
{
System.out.println("Hello World!");
show(new Inter()
{
public void show1() {}
public void show2() {}
});
}
public static void show(Inter in)
{
in.show1();
in.show2();
}
}
|
5.异常
函数内容如果抛出需要检测的异常，那么函数必须要声明异常，否则必须在函数内用try catch捕捉，否则编译失败
如果调用到了声明异常的函数，要么try catch 要么throws， 否则编译失败
功能内容可以解决用catch，解决不了用throws告诉调用者，由调用者解决
一个功能如果抛出了多个异常，那么调用时必须有对应多个catch进行针对性的处理
自定义异常时，继承Exception类(编译时异常），或者RuntimeException类(运行时异常）
子类在覆盖父类方法时，父类的方法如果抛出了异常，那么子类的方法只能抛出父类的异常或者该异常的子类
如果父类抛出多个异常，那么子类只能抛出父类异常的子集。如果父类方法没有抛出异常，那么子类覆盖时绝对不能抛
6.访问权限
包与包之间的类进行访问，被访问的包中的类必须是public的，被访问的包中的类的方法也必须是public的。
public protected default private
同一类中 ok ok ok ok
同一包中 ok ok ok
子类中 ok ok
不同包中 ok
7.线程
创建线程的第一种方式:继承Thread类。
创建线程的第二种方式：实现Runnable接口。
1, 定义类实现Runnable接口。
2, 覆盖接口中的run方法，将线程的任务代码封装到run方法中。
3, 通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。
为什么？因为线程的任务都封装在Runnable接口子类对象的run方法中。
所以要在线程对象创建时就必须明确要运行的任务。
4, 调用线程对象的start方法开启线程。
实现Runnable接口的好处：
1, 将线程的任务从线程的子类中分离出来，进行了单独的封装。按照面向对象的思想将任务的封装成对象。
2, 避免了java单继承的局限性。
所以，创建线程的第二种方式较为常用。
Java Code
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
|
|
class Thread
{
private Runnable r;
Thread()
{
}
Thread(Runnable r)
{
this.r = r;
}
public void run()
{
if(r != null)
r.run();
}
public void start()
{
run();
}
}
class ThreadImpl implements Runnable
{
public void run()
{
System.out.println("runnable run");
}
}
ThreadImpl i = new ThreadImpl();
Thread t = new Thread(i);
t.start();
class SubThread extends Thread
{
public void run()
{
System.out.println("hahah");
}
}
SubThread s = new SubThread();
s.start();
|