内部类
首先讲一下类的五大成员：属性，方法，构造器，代码块，内部类。
内部类就是类中嵌套另外的类，内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类中间的包含关系。
局部内部类
- 局部内部类定义在外部类的方法或者代码块中。
- 可以直接访问外部类的所有成员包括私有成员。
- 不能添加访问修饰符，但是可以使用final。
- 作用域：仅仅在定义它的方法或者代码块中。
- 外部类访问内部类需要在作用于内创建对象。
public class LocalInnerClass {
public static void main(String[] args) {
Outer outer = new Outer();
outer.m1();
}
}
class Outer {
private int n = 1;
public void m3() {
System.out.println("这是m3()方法。");
}
//在方法中或者代码块中写内部类。
public void m1() {
final class Inner {//不能添加访问修饰符，可以使用final修饰。
public void m2() {
System.out.println(n);
m3();
}
}
//外部类在方法中，可以创建内部类对象，然后访问内部类的方法。
Inner inner = new Inner();
inner.m2();
}
}
-
如果外部类和局部类有重名成员时，默认就近原则，如果想访问外部类的成员，则可以使用（外部类.this.成员）
public class LocalInnerClass { public static void main(String[] args) { Outer outer = new Outer(); outer.m1(); } } class Outer { private int n = 1;//外部类的n。 public void m3() { System.out.println("这是m3()方法。"); } //在方法中或者代码块中写内部类。 public void m1() { final class Inner {//不能添加访问修饰符，可以使用final修饰。 private int n=3;//内部类的n; public void m2() { System.out.println(n); System.out.println("外部类的n值是:"+Outer.this.n);//访问外部属性n。 m3(); } } //外部类在方法中可以创建内部类对象，然后访问内部类的方法。 Inner inner = new Inner(); inner.m2(); } }
匿名内部类
定义:本质是类，定义在外部类的局部位置（方法或者代码块中。）
为什么要使用匿名内部类？
因为有些类只是用一次，后面不再使用，所以用匿名内部类简化开发。
基本语法：new 类或者接口{
类体
};
public class Anonymous {
public static void main(String[] args) {
Outer outer = new Outer();
outer.method();
}
}
class Outer {
public void method() {
//IB是编译类型，真正的的运行类型是匿名内部类Outer$1。
IB tiger = new IB() {
@Override
public void cry() {
System.out.println("Tiger叫唤。");
}
};
tiger.cry();
System.out.println(tiger.getClass());//class com.zj.AnonymousInnerClass.Outer$1,实际的匿名内部类类名，它是底层分配的，不显示。
}
}
interface IB{
void cry();
public class Anonymous02 {
public static void main(String[] args) {
Outer02 outer = new Outer02();
outer.method();
}
}
class Outer02{
public void method(){
Father father=new Father("张三"){
};
Mother mother=new Mother() {
@Override
public void hello() {
System.out.println("我是Hello.");
}
};
mother.hello();
System.out.println(father.getClass());
}
}
class Father{
String name;
public Father(String name){
this.name=name;
System.out.println("名字是："+this.name);
}
public void hi(){
}
}
abstract class Mother{
abstract public void hello();
}
//名字是：张三
//class com.zj.AnonymousInnerClass.Outer02$1
//我是Hello.
注意细节
- 可以直接访问外部类的所有成员，包括私有的。
- 不能添加访问修饰符，因为它就是一个局部变量。
- 作用域仅仅在方法或者代码块中。
- 匿名内部类直接访问外部类成员。
- 外部其他类不能访问匿名内部类。
- （类似于局部内部类）如果外部类和内部类重名时，内部类访问的话默认就近原则，如果想访问外部类的成员，则可以使用(外部类.this.成员)
匿名内部类使用的实践：
public class AnonymousExercise02 {
public static void main(String[] args) {
CellPhone cellPhone = new CellPhone();
CellPhone cellPhone1 = new CellPhone();
cellPhone.alarmClock(new Bell() {
@Override
public void ring() {
System.out.println("小猪起床了。");
}
});
cellPhone1.alarmClock(new Bell() {
@Override
public void ring() {
System.out.println("小可爱起床了。");
}
});
}
}
interface Bell{
void ring();
}
class CellPhone{
public void alarmClock(Bell bell){
System.out.println(bell.getClass());
bell.ring();
}
}
//class com.zj.AnonymousInnerClass.AnonymousExercise02$1
//小猪起床了。
//class com.zj.AnonymousInnerClass.AnonymousExercise02$2
//小可爱起床了。
成员内部类：
- 定义在外部类的成员位置上。
- 可以直接访问外部类的所有信息。
- 可以添加任何访问修饰符，因为它本身就是一个成员。
public class MemberInnerClass {
public static void main(String[] args) {
Outer outer = new Outer();
outer.t1();
}
}
class Outer{
private int n=10;
public String name="张三";
//成员内部类。
class Inner{
public void say(){
System.out.println("n="+n+",name="+name);
}
}
public void t1(){
Inner inner = new Inner();
inner.say();
}
}
外部其他类使用成员内部类的三种方式。
1.外部类的对象.new 内部类（语法记住就行。）
public class MemberInnerClass {
public static void main(String[] args) {
Outer outer = new Outer();
outer.t1();
//外部其他类访问成员内部类。
Outer.Inner inner = outer.new Inner();
inner.say();
}
}
class Outer{
private int n=10;
public String name="张三";
class Inner{
public void say(){
System.out.println("n="+n+",name="+name);
}
}
public void t1(){
Inner inner = new Inner();
inner.say();
}
}
2.写一个方法返回一个实例。
public class MemberInnerClass {
public static void main(String[] args) {
Outer.Inner instance = outer.getInstance();
instance.say();
}
}
class Outer{
private int n=10;
public String name="张三";
class Inner{
public void say(){
System.out.println("n="+n+",name="+name);
}
}
public Inner getInstance(){
return new Inner();
}
}
静态成员类
-
使用static修饰。
-
可以直接访问所有静态成员，但是不能访问非静态成员。
-
可以添加任何访问修饰符。因为它的地位相当于一个成员。
-
外部类访问内部类的方式。直接创建一个方法然后new对象再调用静态内部类的方法。
-
外部类和内部类成员重名时,默认就近原则。如果想访问外部类的成员用 外部类.成员。
public class StaticInnerClass01 { public static void main(String[] args) { Outer outer = new Outer(); outer.hi(); } } class Outer{ private int n=11; private static String name="张三"; static class Inner{ public void say(){ System.out.println("name= "+name); } } public void hi(){ Inner inner = new Inner(); inner.say(); } }外部其他类调用静态内部类的方式。
- new 外部类.内部类（）
public class StaticInnerClass01 { public static void main(String[] args) { Outer.Inner inner = new Outer.Inner(); inner.say(); } } class Outer{ private int n=11; private static String name="张三"; static class Inner{ public void say(){ System.out.println("name= "+name); } } }-
写一个方法返回实例。
public class StaticInnerClass01 { public static void main(String[] args) { //外部类调用 Outer outer = new Outer(); Outer.Inner instance = outer.getInstance(); instance.say(); } } class Outer{ private int n=11; private static String name="张三"; static class Inner{ public void say(){ System.out.println("name= "+name); } } //定义一个实例方法。 public Inner getInstance(){ return new Inner(); } }