Java学习笔记之---内部类
（一）成员内部类
- 内部类在外部使用时，无法直接实例化，需要借助外部类信息才能实例化
- 内部类的访问修饰符可以任意，但是访问范围会受到影响
- 内部类可以直接访问外部类的成员，如果出现重名属性，优先访问内部类中定义的
- 可以使用外部类.this.成员的方法，访问外部类中同名的信息
- 外部类访问内部类信息，需要通过内部类实例，无法直接访问
- 内部类编译后.class文件命名：外部类$内部类.class
实例
public class People {
private String name;
private int age;
public Heart getHeart(){
//外部类访问内部类信息，需要通过内部类实例，无法直接访问
new Heart().temp=12;
return new Heart();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void eat(){
System.out.println("人会吃东西");
}
//内部类的访问修饰符可以任意，但是访问范围会受到影响
public class Heart{
int temp=10;
int age=12;
public void beat(){
//内部类可以直接访问外部类的成员，如果出现重名属性，优先访问内部类中定义的
// System.out.println(name+"的"+age+"心脏在跳动");
//可以使用外部类.this.成员的方法，访问外部类中同名的信息
System.out.println(name+"的"+People.this.getAge()+"心脏在跳动");
}
}
}
class PeopleTest{
public static void main(String[] args){
People a=new People();
a.setName("zhang");
a.setAge(10);
//获取内部类对象实例 方法1：new 外部类.new 内部类
// People.Heart aa=new People().new Heart();
// aa.beat();
//获取内部类对象实例 方法2：外部对象.内部类
// People.Heart aa=a.new Heart();
// aa.beat();
//获取内部类对象实例 方法3：外部类对象.获取方法
People.Heart aa=a.getHeart();
aa.beat();
}
}
（二）静态内部类
- 静态内部类中只能访问外部类中的静态成员，如果要访问非静态的成员，需要通过对象实例
- 静态内部类实例时，可以不依赖于外部类对象
- 可以通过
外部类.内部类.成员
的方式，访问内部类中的静态成员 - 当内部类属性于外部类属性同名时，默认直接调用内部类的成员
- 如果要访问外部类中的静态属性，可以通过
外部类.属性
的方式 - 如果要访问外部类中的非静态属性，可以通过 new 外部类（）.属性
的方式
实例
public class People {
private String name;
private static int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void eat(){
Heart c= new Heart();
c.temp=12;
System.out.println(c.temp+"人会吃东西");
}
//内部类的访问修饰符可以任意，但是访问范围会受到影响
public static class Heart{
int temp=10;
int age=12;
//静态内部类中只能访问外部类中的静态成员，如果要访问非静态的成员，需要通过对象实例
public static void say(){
String ll=new People().getName();
//如果要访问外部类中的静态属性，可以通过 外部类.属性 的方式
//如果要访问外部类中的非静态属性，可以通过 new 外部类（）.属性 的方式
System.out.println(ll+People.age+new People().getName());
}
}
}
class PeopleTest{
public static void main(String[] args){
People a=new People();
a.setName("zhang");
a.setAge(10);
//静态内部类实例时，可以不依赖于外部类对象
People.Heart aa=new People.Heart();
//当内部类属性于外部类属性同名时，默认直接调用内部类的成员
People.Heart.say();
}
}
（三）方法内部类
- 定义在方法内部，作用范围也在方法内
- 和方法内部成员使用规则一样，class前面不可以添加public，private，protected，static
- 类中不能包含静态成员
- 类中可以包含final，abstract修饰的成员
实例
public class People {
private String name;
private static int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Object getHeart(){
//和方法内部成员使用规则一样，class前面不可以添加public，private，protected，static
class Heart{
//类中可以包含final，abstract修饰的成员
final int temp=10;
int age=12;
public String beat(){
System.out.println("心在跳动");
return "心在跳动";
}
}
return new Heart().beat();
}
}
class PeopleTest{
public static void main(String[] args){
People a=new People();
a.setName("zhang");
a.setAge(10);
System.out.println(a.getHeart());
}
}
（四）匿名内部类
- 匿名内部类没有类型名称，实例对象名称
- 编译后的文件名：外部类$数字.class
- 无法使用private，public，protected，abstract，static修饰
- 无法编写构造方法，可以添加构造代码块
- 不能出现静态成员
- 匿名内部类可以实现接口，也可以继承父类，但不可兼得
实例
public abstract class Person {
public abstract void read();
}
class PersonTest{
public void getRead(Person a){
a.read();
}
public static void main(String[] args){
PersonTest test=new PersonTest();
//匿名内部类没有类型名称，实例对象名称
//无法使用private，public，protected，abstract，static修饰
//匿名内部类可以实现接口，也可以继承父类，但不可兼得
test.getRead(new Person() {
//无法编写构造方法，可以添加构造代码块
{
//构造代码块
}
@Override
public void read() {
System.out.println("男生");
}
});
test.getRead(new Person() {
@Override
public void read() {
System.out.println("女生");
}
});
}
}