接口、包、内部类

接口

接口：接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。
特点：
1.接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。
2.接口无法被实例化，但是可以被实现。
3.成员变量：只能为常量，且是静态的。
4.没有构造方法。
5.成员方法只能是抽象方法。
声明：Interface关键字用来声明一个接口

例：
 interface 接口名称 [extends 其他的接口名] {
        // 声明变量
        // 抽象方法
}

实现：类使用implements关键字实现接口。

class 类名 implements 接口名 {

}

接口和类的区别：
1.类只能单继承，不支持多继承，可以多层继承。
2.接口可以单继承，也可以多继承。
3.一个类可以实现一个接口，也可以实现多个接口，也可以在继承一个类的同时多实现。
抽象类和接口的区别：
1.抽象类中的方法可以有方法体，但是接口中的方法不行。
2. 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
3.抽象类中的成员方法，可以抽象，也可以非常想；接口中成员方法只能是抽象。
4. 接口中不能含有静态代码块以及静态方法，而抽象类是可以有静态代码块和静态方法。
5. 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

package com.lian5.cn;

public class test {
    public static void main(String[] ages){
        jichuli t=new jichuli();
        t.name="李明";
        t.age=27;
        System.out.println(t.name);
        System.out.println(t.age);
        t.teach();

        teacher t1=new jichu();
        t1.teach();

        System.out.println("-------------------");

        teacher m=new jiuyewang();
        m.name="王刚";
        m.age=29;
        System.out.println(m.name);
        System.out.println(m.age);
        m.teach();

        jiuye m1=new jiuye();
        m1.teach();

    }
}

interface jiekou {

    public  abstract void teach();

}


abstract class teacher {
    String name;
    int age;
    public abstract void teach();

}

class jichu extends teacher implements jiekou{
    @Override
    public void teach(){
        System.out.println("基础班老师讲基础知识");
    }

}

class jiuye extends teacher  {
    @Override
    public void teach(){
        System.out.println("就业班老师讲就业信息");
    }
}

class jichuli extends jichu implements jiekou {
    @Override
    public void teach(){
        System.out.println("基础李老师会说日语");
    }
}

class jiuyewang extends jiuye {
    @Override
    public void teach(){
        System.out.println("就业王老师会讲日语");
    }
}

包

包：（package）就是文件夹。
功能：
1.防止同一路径下命名的冲突。
2.把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
3.包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。
import关键字：
作用：用来导包。例：import 包名
注意：import 声明必须在包声明之后，类声明之前。

内部类

内部类：在类中定义了一个类，这个类就是内部类。
特点：
1.内部类可以直接访问外部类的成员，包括私有。
2.外部类要访问内部类的成员，必须创建对象。
分类：成员内部类、局部内部类
成员内部类：定义在成员位置的类。
访问方式：

例：
1.外部类名.内部类名 对象名 = 外部类对象.内部类对象;
 2. （被静态修饰后） 外部类名.内部类名 对象名 = new 外部类名.内部类名(); 

局部内部类：定义在局部位置的类。局部内部类中的功能，需通过创建内部类对象调用内部类方法来实现。

// 成员变量
private int a = 10 ;
// 成员方法
public void show() {
	// 定义一个局部变量
	final int b = 20 ;
	// 局部内部类
	class Inner {
		public void method(){
			System.out.println(a) ;
			System.out.println(b) ;
		}
	}
	// 创建对象
	Inner n = new Inner() ;
	// 调用
	n.method() ;

}

匿名内部类：局部内部类简写。
存在条件：有一个类或接口。

格式：
new 类名或者接口名(){
		重写方法;
	} ;
例：
 interface Inter {
		public static final int a = 10 ;
	}
	public class test {
		public static void main(String[] args) {
		//匿名内部类
			new Inter() {
				public void show() {
					System.out.println(this.a);
				}
			}.show();
		}
	}