java 33_java33

1.面向接口编程：将实现类对象(键盘鼠标)赋值给接口类型的变量(USB)

interface修饰的类名称

好处：调用时可以是一个方法体即可(实现通用编程)

package 回顾面向对象2.抽象类;

interface Iusb{

void swapdata();

}

class Motherboard{

void plugIn(Iusb u) {

u.swapdata();

}

}

class Mouse implements Iusb{

public void swapdata() {

System.out.println("鼠标移动");

}

}

class Keyboard implements Iusb{

public void swapdata() {

System.out.println("键盘移动");

}

}

public class 面向接口编程 {

public static void main(String[] args) {

Iusb m = new Mouse();

Iusb k = new Keyboard();

Motherboard b = new Motherboard();

b.plugIn(m);

b.plugIn(k);

}

}

2.内部类：在类中定义了一个类

----------优点：

-1增强了封装，不允许外部类访问

-2增强了维护性

-3内部类可以访问外部类中的成员(字段，方法，内部类)

-------------分类：

实例内部类：什么修饰符都没有

静态内部类：前加static

局部内部类：定义在方法中的类

匿名内部类：属于局部内部类的一种特殊情况

3.外部类的修饰符只有两种：public 和默认

内部的修饰符可以有：static，private

4.实例内部类：

class A{

String name = "yy";

class B{

String name = "hh";//内部类方法外

void inner() {

String name = "nn";

System.out.println(name);//nn

//在实例内部类调用**内部类方法外**的对象时

System.out.println(this.name);//hh

//在实例内部类调用外部类的对象时

System.out.println(A.this.name);//yy

}

}

}

public class 实例内部类 {

public static void main(String[] args) {

//创建实例内部类(调用实例内部类，必须创建一个外部类对象)

A out = new A();

A.B in = out.new B();

//调用内部类的方法时

in.inner();

}

【nn

hh

yy】

注：

1.调用实例内部类，必须创建一个外部类对象

2.实例内部类可以访问外部类成员

3.实例内部类中不能有static

4.外部类不能直接访问实例内部类的成员

5.变量的就近原则

5.静态内部类：

class A1{

static int a = 1;

int b = 3;

static class B{

static int a = 2;

void inner() {

System.out.println(a);

System.out.println(A1.a);

System.out.println(new A1().b);

//**在静态内部类中调用外部类成员的时候，**要么成员带有static，要么在静态内部类中创建个匿名对象().成员名

}

}

}

public class 静态内部类 {

public static void main(String[] args) {

//创建静态内部类：

A1.B in = new A1.B();

//调用静态内部类中的非静态方法

in.inner();

//**外界访问静态内部类中的静态成员**

System.out.println(A1.B.a);

}

}

注：

1.不需要创建外部类对象

2.静态内部类可以访问外部类的静态成员(直接调用)和非静态成员(创建外部类匿名对象调用)