抽象类，接口，内部类，包

1 抽象类

1.1抽象类和抽象方法

抽象就是从多个事物中将共性的，本质的内容抽取出来。

抽象类：使用abstract关键字修饰的类就是抽象类。

抽象方法：使用abstract关键字修饰。只有方法的定义，但是没有方法体的方法，该方法的 具体实现由子类完成，包含抽象方法的类需要定义为抽象类。

例子

abstract class Demo {

public abstract void live();

}

1.2抽象类的特点

（1）一个类如果有了抽象方法，那么这个类必须是抽象类。

（2）抽象类里边可以没有抽象方法。

（3）抽象类是不能够被实例化的，不能够创建对象的。

（4）如果一个类继承抽象类，它要么重写抽象类中的所有抽象方法，要么本身也是抽象类。

1.3抽象类的成员特点：

成员变量：子类可以直接继承抽象类中的成员变量。

成员方法：抽象方法在子类中必须要被实现。普通方法可以被子类直接继承使用。

构造方法：抽象类中有构造函数，子类创建对象的时候，调用父类构造函数，为父类中 的成员初始化。

1.4不可以和abstract共存的关键字：

private私有的，外部直接无法访问。抽象方法是为了让子类重写一旦加了private，子 类无法重写

static抽象方法就可以可以通过类名调用，但是这样是没有意义的。

final final修饰的方法不能被重写。所以它和abstract冲突。

2 接口

2.1 接口概念

2.1.1接口理解

接口可以认为是一个特殊的抽象类，当抽象类中的方法都是抽象的，那么该类可以通过接口的形式来表示。解决了java中只能单继承的问题。

接口中定义的方法默认是公有的抽象的，被publicabstract修饰;接口中定义的变量默认为全局常量，使用publicstatic final修饰。

使用abstract修饰的抽象方法在子类中必须实现，而接口在扩展当前类的新功能的时候使用。

定义接口使用interface，实现一个接口使用impentents。

2.1.2接口的特点：

接口是对外暴露规则；

接口是程序的功能扩展；

接口的出现降低了耦合性，使用原则低耦合高内聚；

接口不能直接创建对象，是抽象的，不能实例化；

接口可以用来多实现，类与接口之间是实现关系，可以继承一个类同时实现多个接口。

例子：

interface Person {
public abstract void work();
}
class CarWorker implements Person {
public void workt(){
System.out.println("生产汽车");
}
}
class ITWorker implements Person {
public void work(){
System.out.println("敲代码");
}
}

2.2 接口成员特点：

构造函数：接口没有构造函数；

成员方法：只有抽象方法，默认的修饰符：public abstract;

成员变量：只有 final修饰的常量；默认的修饰符：publicstatic final

2.3类、接口的关系

类与类之间的关系：继承关系，java中只支持单继承，不支持多继承，支持多层继承。

类与接口之间的关系：实现关系，java中支持单实现，也支持多实现。

接口与接口之间的关系：继承关系，java中的接口而言，支持单继承，也支持多继承。

注意：在一般情况下，java中只支持单继承，但是接口是一个特列，接口能实现多继承。

例子：

interface Inter1 {
public abstract void show1();
}
interface Inter2 {
public abstract void show2();
}
// 接口可以多继承
interface Inter extends Inter1, Inter2 {
}
abstract class Fu {
//抽象方法
public abstract void show();
//普通方法
public void method(){
System.out.println("Fu method");
}
}
class Zi extends Fu implements Inter1,Inter2 {
//重写父类中所有的抽象方法
public void show(){
System.out.println("Zi show");
}
//重写接口中的抽象方法
public void show1(){
System.out.println("Zi show1");
}
public void show2(){
System.out.println("Zi show2");
}
}
class InterfaceDemo3 {
public static void main(String[] args) {
Zi z = new Zi();
z.method();
z.show();
z.show1();
z.show2();
}
}

2.4接口与抽象类的区别

共性：都是从不同的类中将公共的内容抽取出来，不断抽取出来的抽象概念

区别：

(1)关键字：

接口：interface

抽象类：abstract

(2)关系：

接口：实现关系，可以多实现；

抽象类：继承关系只能单继承。

(3)成员的区别：

接口：

构造函数：没有

成员方法：抽象方法

成员变量：常量

抽象类：

构造函数：有。

成员方法；普通方法，抽象方法

成员变量：普通变量，常量

(4)什么时候使用抽象类，什么时候使用接口

接口：部分子类必须要做的操作，定义在接口中。

抽象类：所有子类都必须要做的操作，定义在抽象类中

3 内部类

3.1 内部类概念

在类里面定义的类称之为内部类，内部类是外部类的一个成员。

例如：

class A{

class B{

}

}

3.2 内部类访问规则

内部类可以直接访问外部类中成员，包括私有。

外部类访问内部类要建立对象。

之所以内部类可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用：外部类名.this

例子：

class Demo {
private int num = 10;
// 内部类
class InnerDemo{
System.out.println(num); // 内部类直接访问外部类
private int num2 = 20;

}
public void method(){
Test t = new Test(); //外部类访问内部类要建立对象
sop(num2);
}

3.3 成员内部类

定义在类中，方法外。

外部类访问内部类格式：

外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

成员内部类用到的修饰符：

private：提高数据的安全性。内部类被私有private修饰的话，不可以访问。

static：静态内部类。

注意：面试中问类可以被private，static修饰吗？可以的当内部类位于外部类的成 员变量的位置时才可以。

例子：

class Outer {
private int num = 10;
//成员内部类
class Inner {
int num = 20;
public void show(){
int num=30;
System.out.println(num); //30
System.out.println(this.num);// 20
System.out.println(Outer.this.num); //10
}
}
}
class InnerClassDemo2 {
public static void main(String[] args) {
//外部类名.内部类名对象名 = new 外部类名().new 内部类名();
Outer.Inner oi = new Outer().new Inner();
oi.show();
}
}

3.4 静态内部类

就是在成员内部类的基础上加static关键字。

静态内部类访问原则：

静态内部类只能访问外部类的静态成员。

外部类访问静态内部类的方法：

外部类名.内部类名 对象名 = new 外部类名.内部类名();

Outer.Inner oi = new Outer.Inner();

oi.innerShow();

外部类访问静态内部类的静态方法：Outer.Inner.innerShow();

内部类方法是静态的，内部类不是静态的，不能访问。因为内部类中定义了静态成员，内部类必须是静态的。

外部类的静态方法访问内部类时，内部类必须是静态的。

内部类私有并非静态内部类方法是非静态 只能用外部类方法访问。

3.5 局部内部类

在外部类成员方法中定义的内部类。

局部内部类特点：

局部内部类不能被定义为static。Static只修饰成员，不修饰局部。

局部内部类不能被成员修饰符修饰，用于修饰局部内部类的只有final和abstract。

方法内部类只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。

可以直接访问外部类的成员，因为还持有外部类的引用。

3.6 匿名内部类

匿名内部类：没有名字的内部类，是内部类的简化写法。匿名内部类就是一个继承 外部类或者实现接口的子类对象。匿名内部类定义在局部位置。

匿名内部类的前提：继承一个类和接口。

匿名内部类的格式：

new 外部类名或者接口名（）{

重写父类或者接口的抽象方法，也可以定义特有方法

}；

注意：

匿名内部类就是一个匿名子类对象，带内容的对象；

匿名内部类中定义的方法最多不超过3个。

例子：

interface Inter {
public abstract void show();
public abstract void show2();
}
class Outer {
private int num = 10;
public void method(){
// 匿名内部类
new Inter(){
public void show(){
System.out.println("show");
}
public void show2(){
System.out.println("show2");
}
};
new Inter(){
public void show(){
System.out.println("show");
}
public void show2(){
System.out.println("show2");
}
.show();
new Inter(){
public void show(){
System.out.println("show");
}
public void show2(){
System.out.println("show2");
}
}
.show2();
//调用匿名内部类特有方法
new Inter(){
public void show(){
System.out.println("show");
}
public void show2(){
System.out.println("show2");
}
public void function(){
System.out.println("funciton");
}
.function();
//匿名内部类就是一个接口或者外部类的子类对象
Inter inter = new Inter(){
public void show(){
System.out.println("show");
}
public void show2(){
System.out.println("show2");
}
}
inter.show();
inter.show2();
}
}
class NiMingInnerClassDemo {
public static void main(String[] args) {
Outer ou = new Outer();
ou.method();
}
}

4 包

4.1 包的概念

包 package

格式：package name；

import 导入：一个Java源文件只能包含一个package语句，但是可以包含多个import

语句。

import只能导入类，import java.util.*; //导入java.util包中的全部类

导入静态类：import static java.lang.System.*;