内部类是一种类的结果扩充，一个类的内部除了属性和方法外，还可以存在其他类的结构，并且内部类也可以定义在方法或代码块中。
-
基本概念
所谓的内部类指的就是在一个类的内部继续定义其他内部结构类
观察内部类的基本形式：
package oop;
/**
* 观察内部类的基本形式
*/
class Outer{//外部类
private String msg="Hello World!";//属性
class Inner{//内部类
public void print(){
System.out.println(msg);
}
}
public void fun(){
new Inner().print();
}
}
public class TestDeno{
public static void main(String[] args) {
Outer out=new Outer();//实例化对象
out.fun();
}
}
内部类的基本形式就是将类的定义拿到类的内部，也就是说除了属性和方法外，也可以定义属于自己内部的结构体。这样做最大的缺点在于破坏了类的结构性。它最大的帮助就是可以轻松地访问外部类中的私有属性。
将内部类放在外部并且实现同样功能：
package oop;
/**
* 将内部类放在外部同样实现此功能
*/
class Outer1{
private String msg="Hello World!";//属性
public void fun(){
//this表示当前调用fun()方法的对象，在本程序中主方法由Out对象调用，所以this就是out
new Inner1(this).print();//实例化对象调用print()方法
}
//内部类需要访问msg属性，但是此属性属于Outer1类，而在Outer1类里面此属性使用Private进行封装
//所以如果此时要得到这个属性的内容，需要定义一个getter方法
public String getMsg(){
return this.msg;
}
}
class Inner1{
private Outer1 out;//必须依靠对象才可以调用getMsg()方法
public Inner1(Outer1 out){//在构造方法中接收外部类对象
this.out=out;
}
public void print(){
System.out.println(this.out.getMsg());
}
}
public class TestDemo {
public static void main(String[] args) {
Outer1 out=new Outer1();
out.fun();
}
}
所以内部类的最大好处就是可以方便地访问外部类中的私有属性。
外部类访问内部类的私有属性：
package oop;
/**
* 访问内部类的私有属性
*/
class Outer2{
private String msg="Hello World!";
class Inner2{
private String info="世界 你好!";
public void print(){
System.out.println(Outer2.this.msg);
}
}
public void fun(){
Inner2 in=new Inner2();
System.out.println(in.info);
in.print();
}
}
public class TestDemo{
public static void main(String[] args) {
Outer2 out=new Outer2();
out.fun();
}
}
外部类可以直接利用内部类的对象使用"对象.属性"的形式访问私有属性操作。
内部类对象的实例化语法操作：
外部类.内部类 对象=new 外部类().new 内部类();
内部类对象的实例化语法格式只是一个基础，指的是在一个内部类只定义一个内部类的情况，而如果一个内部类中又定义了内部类，则类结构需要继续向下延伸：
外部类.内部类1.内部类2 对象=new 外部类().new 内部类1().new 内部类2();
实例化内部类对象:
package oop;
/**
* 实例化内部类对象
*/
class Outer3{
private String msg="Hello World!";
class Inner3{
private String in="罗小齐草泥马！";
public void print(){
System.out.println(Outer3.this.msg);
System.out.println(in);
}
}
}
public class TestDemo {
public static void main(String[] args) {
Outer3.Inner3 in=new Outer3().new Inner3();
in.print();
}
}
如果一个内部类只希望被一个外部类访问，不能被外部调用，那么可以使用private定义私有内部类
-
使用static定义内部类
使用static定义的属性或方法是不受实例化对象控制的，所以如果使用static定义内部类，它一定不可能受到外部类的实例化对象控制
如果一个内部类使用static定义，那么这个内部类就变为一个"外部类",并且只能访问外部类中定义的static操作。相当于定义一个外部类。
使用如果想要取得内部类的实例化对象，其语法格式如下：
外部类.内部类 对象=new 外部类.内部类();
实例化"外部类"对象：
package oop;
/**
* 使用static定义内部类
*/
class Outer4{
private static String msg="Hello World!";
static class Inner4{
private String in="HelloWorld!";
public void print(){
System.out.println(Outer4.msg);
System.out.println(in);
}
}
}
public class TestDemo {
public static void main(String[] args) {
Outer4.Inner4 in=new Outer4.Inner4();
in.print();
}
}
实例化内部类的操作有如下两种格式：
-
在方法中定义内部类
内部类理论上可以在类的任意位置上进行定义，包括在代码块中，或在普通方法中。
在普通方法中定义内部类:
package oop;
/**
* 在方法中定义内部类
*/
class Outer5{
private String msg="Hello World!";
public void fun(){
class Inner5{
private String in="今天天气很适合在家敲代码！";
public void print(){
System.out.println(Outer5.this.msg);
System.out.println(in);
}
}
new Inner5().print();
}
}
public class TestDemo {
public static void main(String[] args) {
Outer5 out=new Outer5();
out.fun();
}
}
访问方法中定义的参数或变量：
package oop;
/**
* 访问方法中内部类定义的参数或变量
*/
class Outer6{
private String msg="Hello World!";
public void fun(int num){
double score=99.9;
class Inner6{
private String in="今天天气真好";
public void print(){
System.out.println(in);
System.out.println("属性："+Outer6.this.msg);
System.out.println("方法参数:"+num);
System.out.println("方法变量:"+score);
}
}
new Inner6().print();
}
}
public class TestDemo {
public static void main(String[] args) {
Outer6 out=new Outer6();
out.fun(100);
}
}
