这是我来到西部开源的第八天。
这一天，我学到了以下的知识。
abstract
抽象的，可以修饰类，修饰方法。
特点：
一旦一个类中，有了抽象方法，此类必须为抽象类。抽象类可以有非抽象方法
抽象类不能直接创建对象，可以采用多态间接的去实例化抽象类
抽象类，就是被abstract所修饰的类，父类将所有的子类的共性功能向上抽取后，父类并不知道每个子类对这个共性功能的具体实现，所以没必要在父类中，给出共性功能的具体实现，而是给出声明即可。所谓给出功能的声明，就是将此功能抽象出来，然后强制子类必须重写抽象的功能
抽象类的子类，要么重写父类的所有抽象方法，要么自己也是抽象类
抽象类中有构造方法，用来让子类初始化父类
abstract不能和private、final、static共存
接口
用来定义一些扩展功能，哪些事物将来要具备这个功能，就可以实现这个接口，然后对功能做出具体的实现（定义一些规范）。
特点：
接口不能new对象
interface可以定义接口，implements可以实施接口
接口中成员变量的特点：接口中的成员变量全都是静态的公共常量（有默认的修饰符 public static final）
接口中成员方法的特点：只能是抽象方法（默认修饰符 public abstract）
接口中构造方法的特点：接口中没有构造方法
类与类,类与接口,接口与接口的关系
a:类与类：
继承关系,只能单继承,可以多层继承。
b:类与接口：
实现关系,可以单实现,也可以多实现。
并且还可以在继承一个类的同时实现多个接口。
c:接口与接口：
继承关系,可以单继承,也可以多继承。
抽象类和接口的区别
A:成员区别
抽象类：
成员变量：可以变量，也可以常量
构造方法：有
成员方法：可以抽象，也可以非抽象
接口：
成员变量：只可以常量
成员方法：只可以抽象
B:关系区别
类与类
继承，单继承
类与接口
实现，单实现，多实现
接口与接口
继承，单继承，多继承
C:设计理念区别
抽象类 被继承体现的是：”is a”的关系。 抽象类中定义的是该继承体系的共性功能。
接口 被实现体现的是：”like a”的关系。 接口中定义的是该继承体系的扩展功能。
注意：JDK1.8之后在接口中提供了用default修饰的方法，可以给出功能的具体实现，子类可以继承下去用
传参和返回值
传参
- 形式参数是基本类型，要的是该类型的成员
- 形式参数是类名，要的是该类的对象
- 形式参数是抽象类名，要的是该抽象类的子类对象
- 形式参数是接口类型，要的是该接口的子类对象
返回值
- 返回值类型是基本类型，返回的是该类型的成员
- 返回值类型是类名，要的是该类的一个对象
- 返回值类型是抽象类名，要的是该抽象类的一个子类对象
- 返回值类型是接口类型，要的是该接口的一个子类对象
链式编程
当调用完一个方法后，方法的返回值又是一个对象，那么就可以紧接着打点再去调用对象的方法。
有关链式编程的例子：
public class MyTest {
public static void main(String[] args) {
//链式编程
//Student student = new Student();
//Student student1 = student.getStudent(new Student(), 100);
//student1.show(109);
//链式编程：当你调用完一个方法之后，方法的返回值又是一个对象，那么你就可以紧接着打点再去调用对象的方法
Student student = new Student();
new Student().getStudent(student, 100).show(109);
System.out.println(student.num); //
}
}
class Student {
int num = 10;
public Student getStudent(Student stu, int num) {
stu.num = num;
return this;
}
public void show(int num) {
this.num = num;
}
}
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
package
用来解决同一个路径下不能存在同名文件的问题，实质就是文件夹（package）。
格式：package 包名;// 多级包用，分开即可
定义包的注意事项：
package语句必须是程序的第一条可执行的代码
package语句在一个java文件中只能有一个
如果没有package，默认表示无包名
import
不同包下的类之间的访问，我们发现，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能（import）。
格式：import 包名;// 这种方式导入是到类的名称。 虽然可以最后写*，但是不建议。
常见的修饰符总结
四种常见修饰符（ private(私有的) , 默认 , protected(受保护的) , public(公共的) ）的访问权限如下所示：
修饰符\路径 本类 同一个包下（子类和无关类） 不同包下（子类） 不同包下（无关类）
private（私有的） √
默认 √ √
protected（受保护的） √ √ √
public（公共的） √ √ √ √
在Java中，修饰符的运用如下所示：
A:修饰符：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract
B:类：
权限修饰符：默认修饰符，public
状态修饰符：final
抽象修饰符：abstract
用的最多的就是：public
C:成员变量：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
用的最多的就是：private
D:构造方法：
权限修饰符：private，默认的，protected，public
用的最多的就是：public
E:成员方法：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract
用的最多的就是：public
F:除此以外的组合规则：
成员变量：public static final
成员方法：public static
public abstract
public final
内部类
将一个类定义到另一个类的内部，那么这个类就叫做内部类。根据定义的位置不同，可以分为成员内部类和局部内部类。
成员内部类
- 定义：在外部类的成员位置定义的类，被称为成员内部类。
- 若想在测试类中直接访问内部类，需要在测试类中定义内部类对象。
格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象
- 成员内部类的修饰符：private（为了保证数据的安全性），static（为了方便访问数据）。注意事项：静态内部类访问的外部类数据必须用静态修饰，且成员方法可以是静态的也可以是非静态的。
若成员内部类被静态修饰，访问的格式为：外部类名.内部类名 对象名 = new 外部类名.内部类名();
- 成员内部类的面试题
要求：使用已知的变量，在控制台输出30，20，10。
class Outer {
public int num = 10;
class Inner {
public int num = 20;
public void show() {
int num = 30;
System.out.println(?); // num
System.out.println(??); // Inner.this.num
System.out.println(???); // Outer.this.num
}
}
}
class InnerClassTest {
public static void main(String[] args) {
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
局部内部类
- 定义：在外部类的局部位置定义的类，被称为局部内部类。
- 局部内部类可以直接访问外部类的成员，包括私有。
外部类想要访问局部内部类的成员，要先创建内部类的对象，通过对象调用内部类方法，来使用局部内部类的功能。
- 局部内部类想要访问外部类的局部变量，必须要用final修饰（因为局部变量会随着方法的调用完毕而消失，这个时候，局部对象并没有立马从堆内存中消失，还要使用那个变量。为了让数据还能继续被使用，就用fianl修饰，这样，在堆内存里面存储的其实是一个常量值。JKD1.8以后会默认加上final）。
- 匿名内部类：是局部内部类的简写。本质上是一个对象，是实现了该接口或继承了该抽象类的子类对象。可以给匿名内部类起名，以此可以调用类中的多个成员方法，并作为参数返回。
格式：new 类名或者接口名(){ 重写方法; } ;
类中定义接口
在外部类中定义一个接口，并且以接口的形式在测试类中调用外部类的接口
代码如下：
public class MyTest {
public static void main(String[] args) {
//间接方式
Outer outer = new Outer();
outer.waiShow();
//直接方式
new Outer.Inner() {
@Override
public void show() {
System.out.println("重写了接口中的show方法2222");
}
}.show();
Outer.Inner inner= new Outer.Inner() {
@Override
public void show() {
System.out.println("重写了接口中的show方法2222");
}
};
inner.show();
inner.show();
}
}
class Outer{
//成员内部接口
interface Inner{
void show();
}
public void waiShow(){
new Inner(){
@Override
public void show() {
System.out.println("重写了接口中的show方法");
}
}.show();
}
}
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