Java学习-看完这一篇文章，了解内部类

今天给大家分享一下内部类的知识，内部类是Java中比较难理解的一部分内容。但如果理清楚了，其实很简单。
内部类的分类
内部类分为四类

• 成员内部类
• 静态成员内部类
• 局部内部类
• 匿名内部类

内部类是什么，就是类里面的类

成员内部类

成员内部类，和成员方法，成员变量的"地位"相似

public class Outer {
/**
* 成员变量
*/
public int Num = 100;
/**
* 成员方法
*/
public void f(){
System.out.println("外部类的成员方法被调用");
}
/**
* 成员内部类
*/
public class Inner{
public void method(){
System.out.println(Num);
f();	//这里可以看到，在内部类的成员方法中可以直接使用外部类的成员方法，
//也可以使用外部类的成员变量
}
}

public static void main(String[] args) {
/*
成员内部类的实例化
外部类.内部类 oi = new 外部类().new 内部类();
*/
Outer.Inner oi = new Outer().new Inner();
//调用内部类的成员方法
oi.method();
实例化的内部类对象只能调用内部类自己的成员变量成员方法，无法调用外部类的
}
}

成员内部类实例化
/*
成员内部类的实例化
外部类.内部类 oi = new 外部类().new 内部类();
*/

静态成员内部类

就是在成员内部类的前面加上static关键字

public class Outer {
/**
* 静态成员变量
*/
public static int number = 10;
/**
* 静态成员方法
*/
public static void staticMethod(){
System.out.println("静态方法被调用");
}

/**
* 静态成员类只能调用外部类的静态方法和静态变量
*/
public static class Inner{
public void method(){
System.out.println(number);
staticMethod();
}
}
public static void main(String[] args) {
/**
* 创建格式：外部类.内部类 oi = new 外部类.内部类()；
*/
Outer.Inner oi = new Outer.Inner();
oi.method();
}
}

局部内部类

局部内部类是指在类的方法中创建类

public class Outer {
/**
* 成员变量
*/
public int Num = 100;

/**
* 成员方法
*/
public void f(){
System.out.println("外部类的成员方法被调用");
}

/**
*成员方法中定义一个成员内部类
*/
public void findInner(){
//局部内部类
class Inner{
//局部内部类的成员变量
int number;
//局部内部类的成员方法
public void method(){
//可以随便调用外部类的成员变量和方法
System.out.println(Num);
f();
}
}
/** 因为是局部内部类，只在方法中有用，所以不加修饰符
*  创建对象时，需要在方法内部创建
*/
Inner inner = new Inner();
inner.method();

}

public static void main(String[] args) {
Outer outer = new Outer();
/**
* 调用局部内部类，需要创建外部类对象，然后调用方法
*/
outer.findInner();
}
}

匿名内部类

匿名内部类也就是没有名字的内部类

正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写

但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口

• 基于抽象类的内部类

基于抽象类的内部类
abstract class AbstractType {
abstract public void test();
}

class TypeA extends AbstractType {

@Override
public void test() {
System.out.println("一个类继承abstract修饰的类，完成abstract方法");
}
}

public class Demo1 {
public static void main(String[] args) {
TypeA typeA = new TypeA();
typeA.test();

/*
new AbstractType() {
// 这里是类的本体
}
这里不存在类名，但是该类的本体是一个类继承了abstract修饰的类可以
实现的类的本体。这里可以认为定义了的是一个abstract的一个子类
并且创建了一个abstract的子类对象，赋值给了abstract修饰的类的
引用数据类型变量
*/
AbstractType at = new AbstractType() {
@Override
public void test() {
System.out.println("匿名内部类的对象，调用方法");
}
};

at.test();

new AbstractType() {

@Override
public void test() {
System.out.println("匿名内部类的匿名对象。可以调用方法");
}
}.test();

testInnerType(typeA);

testInnerType(new AbstractType() {
@Override
public void test() {
System.out.println("匿名内部类对象，直接作为方法的参数使用！！！");
}
});
}

public static void testInnerType(AbstractType at) {
at.test();
}
}

• 基于接口的内部类

2.基于接口的内部类
import java.util.Arrays;
import java.util.Comparator;

interface A {
public void testA();
}

public class Demo2 {
public static void main(String[] args) {
/*
这里定义的是一个接口A 的引用，指向的是一个接口的匿名内部类的对象
new A() 之后的大括号内容是一个类遵从接口A之后完成的代码
*/
A a = new A() {
@Override
public void testA() {
System.out.println("接口的匿名内部类对象");
}
};

a.testA();

new A() {

@Override
public void testA() {
System.out.println("接口匿名内部类的匿名对象，直接调用方法");
}
}.testA();

test(new A() {
@Override
public void testA() {
System.out.println("接口匿名内部类的匿名对象，直接作为方法的参数使用");
}
});

Person p1 = new Person(1, "无双剑姬");
Person p2 = new Person(2, "无极剑圣");
Person p3 = new Person(3, "疾风剑豪");
Person p4 = new Person(4, "影流之主");
Person p5 = new Person(5, "刀锋意志");
Person p6 = new Person(6, "瑞文");

Person[] arr = {p2, p1, p5, p4, p3, p6};

Arrays.sort(arr, new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
return o2.getId() - o1.getId();
}
});

System.out.println(Arrays.toString(arr));
}

public static void test(A a) {
a.testA();
}
}
//Person类
class Person {
private int id; //id
private String name;  //姓名

//构造方法
public Person() {
}
public Person(int id, String name) {
this.id = id;
this.name = name;
}
//成员变量的get和set方法
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;	 }

@Override
public String toString() {
return "Person{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}

@Override
public boolean equals(Object obj) {
System.out.println("equals被调用");
if (this == obj) {
return true;
}

if (!(obj instanceof Person)) {
return false;
}

Person p = (Person) obj;
return p.name.equals(this.name) && this.id == p.id;
}

@Override
public int hashCode() {
System.out.println("hashCode被调用");
return id;
}
}

这些代码希望大家可以自己动手敲一遍，有不懂得可以留言

内部类可以写链表，简化代码等作用

一道面试题…😊

下一篇分享一下接口和抽象类的区别

面试题答案😂，有其他方法的小伙伴在评论区留言