Java学习记录 Day8（abstract、接口、内部类） - 好文

<>Day 8

2019年4月14日。
这是我学习Java的第八天。
这一天，我学到了以下的知识。

<>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; } }
<>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(); } }
* 局部内部类
- 定义：在外部类的局部位置定义的类，被称为局部内部类。
- 局部内部类可以直接访问外部类的成员，包括私有。
外部类想要访问局部内部类的成员，要先创建内部类的对象，通过对象调用内部类方法，来使用局部内部类的功能。
-
局部内部类想要访问外部类的局部变量，必须要用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(); } }

热门工具换一换