Java面试集合（六）

系统管理员 2021-09-16 05:10 343阅读 0赞

![标题图][1240]

## 1. abstract抽象 ##

什么是`abstract`，中文为抽象，从具体事物抽出，概括它们共同的方面，本质属性与关系等，称为抽象。**看不见，摸不着的东西叫做抽象，抽象是人们对世界万物的感觉，用特定的图像表达出来，要理解抽象的东西，就必需从内心感受它们。**

#### 什么是抽象类 ####

抽象类的定义和使用格式

abstract class 类名{ 
           类体
    }

class 类名 extends 抽象类 { 
              //实现全部抽象方法
    }

抽象类，用`abstract`修饰的类为抽象类，一个类如果它的所有子类都重写了这个方法，那么给它添加抽象的声明，那么这个类就为抽象类。

那么这个抽象方法的类就为抽象类，具有抽象方法的类为抽象类，但抽象类不一定具有抽象方法，**抽象类中可以有构造方法，不能创建对象。**

抽象类中如果有抽象方法，那么**子类继承这个抽象类之后，就必须要重写抽象类中的 所有抽象方法。**

一个类用`abstract`进行修饰为抽象类，那么这个抽象类不能在用`final`来修饰了，抽象类是类对象的抽象集合，抽象类使用`abstract`关键字修饰，`abstract`不能与`final`并列修饰同一个类。

> 对于抽象方法，不能在用`static`和`final`和`private`来修饰

在抽象类中具体**抽象的是属性和行为，**在抽象类中，含有抽象方法的类为抽象类，一定是抽象类，但抽象类中不一定含有抽象方法。

案例：

//抽象类：作为抽象方法是可以重载的
    public abstract class Person { 
     public abstract void run();
    }
    
    //子类继承抽象类
    public class Studentone extends Person{ 
     @Override
     public void run(){
      System.out.println("人会跑");
     }
    }
    
    //测试
    public class Test { 
     public static void main(String[] args){
      Person person = new Student();
      person.run();
     }
    }
    
    //结果
    人会跑

## 2. 接口 ##

#### 什么是接口（interface） ####

接口中的方法**都是抽象方法**，`public`权限，全是抽象函数，**不能生成对象**

interface Student{ 
    public void read();
    public void write();
    }
    
    class ChineseStudent implements Student{ 
    //复写
    public void read(){
     System.out.println("read");
    }
    public void write(){
     System.out.println("write");
    }
    }
    
    class Test{ 
    public static void main(String args[]){
     ChineseStudent chinesestudent = new ChineseStudent();
     Student student = chinesestudent;
    
     student.read();
     student.write();
    }
    }

> 接口的定义和使用格式

interface 接口名 {
              [public] [static] [final] 变量;
              [public] [abstract] 方法;
    }

class 类名 implement 接口列表 { 
              //实现所有接口中声明的方法
    }

什么是接口呢？这个类中所有的方法都是抽象方法。

> **接口**不同抽象，**没有构造方法**，接口不是一个类。
> 
> **接口中也不能创建对象**，抽象方法也不能。

在`JDK1.8`以前，`interface`来定义接口，通过`implements`关键字让接口和类产生关系，类实现接口，要重写接口中的所有抽象方法。

在`Java`中只有单继承，多实现，一个类可以继承一个父类，但一个类可以实现多个接口。

实现接口用implements关键字，
    一个接口可以实现多个接口，
    一个接口可以继承多个接口
    interface Student{
    public void read();
    public void write();
    }
    
    interface Teacher{
    public void teach();
    public void test();
    }
    
    class Person implements Student,Teacher{
    public void read(){
     System.out.println("read"):
    }
    public void write(){
     System.out.println("write");
    }
    public void teach(){
     System.out.println("teach"):
    }
    public void test(){
     System.out.println("test"):
    }
    }

// 测试
    class Test{ public static void main(String args[]){ Person person = new Person(); Student student = person; student.read(); student.write(); Teacher teacher = person; teacher.teach(); teacher.close(); } }

> 接口解决了**多继承的问题**，将多继承的这种机制在`java`中通过接口实现了，接口与接口之间是继承的关系。

interface A{ 
     void showa();
    }
    interface B{ 
     void showb();
    }
    class C implements A,B{ 
     public void showa(){};
     public void showb(){};
    }

接口中的属性默认是使用`public static final`修饰的

interface A { 
    void add();
    }
    class B implements A { 
     // 接口中的方法默认是使用public修饰
    void add(){}
    }

> 实现多接口，存在方法名一致时，会导致方法重写的时候产生歧义。

#### 抽象类和接口比 ####

*  **抽象类是对类抽象，而接口是对行为的抽象。**
 *  抽象类为继承关系，接口为实现类与接口之间的契约关系。
 *  抽象类为单继承，接口为多“继承”。子类只能继承一个抽象类，但可实现多个接口。

#### 代码 ####

//抽象类
    abstract class Person { 
     abstract void run();
     abstract void jump();
    }
    
    //接口
    interface School{ 
     void go();
    }
    
    //实现
    class Student extends Person implements School{ 
     void run();
     void jump();
     void go();
    }

> 抽象类中成员变量默认为`friendly`，函数修饰符`public，protected，default`。
> 
> 接口**属性为静态**，`public static final`，**成员**函数为`public`。

## 3. 内部类 ##

**内部类的分类：**

*  静态内部类
 *  局部内部类
 *  成员内部类
 *  匿名内部类

// 外部类
    class Demo{ 
     private int num = 3;
     // 定义内部类
     class Int{ 
      void show(){
       System.out.println("num="+num); 
      }
     }
    
     void method(){
      Int int = new Int();
      int.show();
     }
    }
    
    class Inner{ 
     public static void main(Stirng[] args){
      Demo demo = new Demo();
      demo.method();
     }
    }

内部类有 非静态，静态，匿名类

**语法:**

> new 外部类().new 内部类()

#### 成员内部类： ####

在成员变量的位置上定义的类为成员内部类。  
如果要使用成员内部类就要使用**外部类.内部类来访问。**

#### 静态内部类： ####

在成员位置上用`static`修饰的内部类为静态内部类。

静态内部类**只能访问**外部类的静态成员和本内部类的成员；且**不能访问外部类的非静态成员**。

#### 匿名内部类：（对应类的子类或者对应接口的实现类） ####

是一种特殊的局部内部类。

访问外部类中的内部类，非静态

Outer.Inner int = new Outer().new Innter();

对静态内部类中的非静态成员

Outer.Inner int = new Outer().new Innter();

用`static`声明的内部类，则内部类变成外部类，用`static`声明的内部类不能访问非`static`的外部类属性，外部类的属性要用`static`才能访问。

内部类可以使用外部类所有的方法和变量，就算被私有化也一样可以，如：

class Outer{ 
     private int x;
     // 创建内部类的实例
     Inner inner = new Inner();
     public void do(){
      // 调用内部类的方法
      inner.go();
     }
     // 内部类
     class Inner{ 
      void go(){
       x = 30;
      }
     }
    }

## 4. 包 ##

在`java`中提供了不同的类和接口存放在不同的包中。

常见的包

java.applet
    java.awt
    java.net
    java.util
    java.lang
    java.awt GUI
    java.io 数据传输
    java.math  数学运算
    java.nio 高并发
    java.net  网络编程
    java.text  格式化
    java.sql  和数据库交互

包的格式：

package 包名[.子包名[…]];

引入`java`包

import 包层次结构的类名;

#### 垃圾分代回收机制 ####

垃圾分代回收机制针对堆内存，所有内存由`Java`自动分配到回收，垃圾收集器。

## 结语 ##

*  下面我将继续对`Java`、 `Android`中的其他知识 深入讲解 ，有兴趣可以继续关注
 *  小礼物走一走 or 点赞

[1240]: /images/20210724/7b63291f57294206a9442fba94e995a9.png