一.接口 java中的继承关系是单继承，如果有多个父类的时候，可以考虑使用接口进行实现。接口常常被广泛的使用。 1.了解 使用interface来修饰 接口中可以包含多个方法，且方法跟抽象
一.接口
java中的继承关系是单继承，如果有多个父类的时候，可以考虑使用接口进行实现。接口常常被广泛的使用。
1.了解
使用interface来修饰接口中可以包含多个方法，且方法跟抽象类的抽象方法一致，可以不实现，子类在实现的时候必须要实现代码逻辑，子类实现接口使用implements关键字2.接口特性
- 接口中的所有方法都是抽象方法，不能包含方法的实现
- 接口中的所有方法的访问修饰权限都是public，不写不是默认访问权限，而是public
- 接口不能被实例化，不能new
- 接口的子类必须要实现接口中的所有方法，跟抽象类有所不同，抽象类中的抽象方法必须要被实现
- 实现类可以实现多个接口
- 接口中的变量都是静态常量，如果变量没有使用static修饰，也表示静态常量，不使用final，也是静态常量
- 抽象类可以实现接口，并且不实现接口中的方法，而接口只能继承接口，不能实现接口。
3.代码实现USB接口
public interface Usb { public void dataTransfer(); public void play();}public class UPan implements Usb { @Override public void dataTransfer() { System.out.println("upan可以传输数据"); }}public class Mouse implements Usb{ @Override public void dataTransfer() { System.out.println("鼠标来点击屏幕"); }}public class Test { public static void main(String[] args) { Mouse mouse = new Mouse(); mouse.dataTransfer(); UPan up = new UPan(); up.dataTransfer(); }}
4.使用
1.接口代表一种能力，接口中可以定义多个方法，子类在实现的时候，必须要实现这些方法，将这些方法实现就代表具备方法的能力。
2.关心实现类有何能力，而不关心实现细节
旺财是一只狗------is-a
旺财有一个鼻------has-a
3.接口是一种约定
4.规则
- 可以定义一个新接口，用extends去继承一个已有的接口
- 可以定义一个类，用implements去实现一个接口中所有方法。
- 可以定义一个抽象类，用implements去实现一个接口中部分方法。
二.内部类
内部类（当作类中的一个普通成员变量，只不过此成员变量是class的类型）：
一个java文件中可以包含多个class，但是只能有一个public class，如果一个类定义在另一个类的内部，此时可以称之为内部类
1.使用
创建内部类的时候，跟之前的方法不一样，需要在内部类的前面添加外部类来进行修饰
InnerClassDemo.InnerClass inner = new InnerClassDemo().new InnerClass();
2.特点
内部类可以方便的访问外部类的私有属性 外部类不能访问内部类的私有属性,但是如果创建了内部类的对象，此时可以在外部类中访问私有属性 内部类中不能定义静态属性 当内部类和外部类具有相同的私有属性的时候，在内部类中访问的时候，可以直接访问内部类的属性public class Outer {
private String name = "zhangsan";
class Inner{
private String name = "lisi";
public void show(){
System.
out.
println(
name);
System.
out.
println(
this.
name);
System.
out.
println(
Outer.
this.
name); } }
public static void main(
String[]
args) {
Outer.
Inner inner = new Outer().
new Inner();
inner.
show(); }}
如果需要访问外部类的属性，那么需要添加 外部类类名.this.属性。public class InnerClassDemo {
private int id;
private String name;
public int getId() {
return id; }
public void setId(
int id) {
this.
id = id; }
public String getName() {
return name; }
public void setName(
String name) {
this.
name = name; }
public void show(){
System.
out.
println(
"show");
// System.out.println(age); InnerClass inner = new InnerClass();
System.
out.
println(
inner.
age);
//创建了内部类的对象，此时可以在外部类中访问私有属性 }
class InnerClass{
private int age;
// static String name = "zhangsan"; public void test(){
System.
out.
println(
"test");
System.
out.
println(
id);
System.
out.
println(
name); }
class InnerInner{
private int id;
public void print(){
System.
out.
println(
"print"); } } }
public static void main(
String[]
args) {
InnerClass innerClass = new InnerClassDemo().
new InnerClass(); }}
public class TestInnerClass {
public static void main(
String[]
args) {
// System.gc(); InnerClassDemo innerClassDemo = new InnerClassDemo();
innerClassDemo.
show();
System.
out.
println(
innerClassDemo.
getName());
InnerClassDemo.
InnerClass inner = new InnerClassDemo().
new InnerClass();
inner.
test();
// System.out.println(inner.age); InnerClassDemo.
InnerClass.
InnerInner innerInner = new InnerClassDemo().
new InnerClass().
new InnerInner(); }}
3.分类
匿名内部类：当定义了一个类，实现了某个接口的时候，在使用过程中只需要使用一次，没有其他用途其实考虑到代码编写的简洁，可以考虑不创建具体的类，而采用new interface(){添加未实现的方法}就叫做匿名内部类public class NoNameInnerClassDemo {
public static void main(
String[]
args) {
System.
out.
println(
"有一万行代码");
new Thread(
new Runnable() {
@Override public void run() { }
//看似NEW了一个接口，实则是类里的实现方法 });
System.
out.
println(
"有一万行代码"); }}
class Runner implements Runnable{
@Override public void run() { }}
静态内部类：在内部类中可以定义静态内部类，使用static关键字进行修饰，使用规则外部类.内部类 类的引用名称 = new 外部类.内部类（）public class StaticClass {
private int id;
public void test(){
System.
out.
println(
"test"); }
static class InnerClass{
private String name;
public void show(){
System.
out.
println(
"show"); } }
public static void main(
String[]
args) {
InnerClass innerClass = new StaticClass.
InnerClass();
//静态类通过类名调用，无()// InnerClass innerClass = new StaticClass().new InnerClass();//内部类看作外部类的一个对象，有() }}
方法内部类：在外部类的方法中也可以定义类，此时叫做方法内部类使用的时候需要注意，只能在方法中创建对象，因为此class的作用域就是当前方法方法内部类不能在外部类的方法以外的地方使用，所以方法内部类丌能使用访问控制符和static修饰符public class MethodInnerClass {
public void show(
int number){
System.
out.
println(
"show");
class InnerClass{
private String name;
public void test(
int a){
System.
out.
println(
"test");
System.
out.
println(
a);
System.
out.
println(
number); } }
new InnerClass().
test(
888); }
public static void main(
String[]
args) {
MethodInnerClass methodInnerClass = new MethodInnerClass();
methodInnerClass.
show(
666); }}
