内部类
内部类分类
- 成员内部类
- 局部内部类
- 匿名内部类
- 静态内部类
/**
* 〈一句话功能简述〉<br>
*
* @author hjsjy
* @create 2018/10/8
* @since 1.0.0
*/
public class OuterClass {
private String name;
private int age;
public void dis(){
System.out.println("name:"+getName());
}
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 class InnerClass{
public InnerClass(){
name="hjsjy";
age=21;
}
public OuterClass getOuterClass(){
return OuterClass.this;
}
public void display(){
System.out.println("name:"+getName()+";age="+getAge());
}
}
public static void main(String[] args) {
OuterClass outerClass = new OuterClass();
OuterClass.InnerClass innerClass = outerClass.new InnerClass();
innerClass.getOuterClass().dis();
}
}
成员内部类
- 成员内部类可以无条件访问外部类的成员属性和成员方法(包括private和静态成员)
- 成员内部类和外部类同名的成员变量或者方法时候，会发生隐藏现象，即默认访问的是成员内部类的成员，如果要访问外部类的成员需要按下面的形式进行访问：
外部类.this.成员变量
外部类.this.成员方法
public class Circle {//外部类
private double radius=0;
public static int count=1;
public Circle(double radius){
this.radius=radius;
}
class Draw{//内部类
public void drawShape(){
System.out.println(radius);
System.out.println(count);
}
}
}
外部类想访问成员内部类的成员，要先创建一个成员内部类的对象
class Circle{
private double radius=0;
public Circle(double radius){
this.radius=radius;
getDrawInstance().drawShpae();//必须先创建成员内部类的对象，在访问
}
private Draw getDrawInstance(){
return new Draw();
}
class Draw{
public void drawShpae(){
System.out.println(radius);//外部类的private成员
}
}
}
成员内部类是依附外部类而存在的，创建成员内部类的对象，前提是必须存在一个外部类的对象
public class Test {
public static void main(String[] args) {
Outter outter = new Outter();
Outter.Inner inner = outter.new Inner();//1
Outter.Inner inner1 = outter.getInnerInstance();//2
}
}
class Outter {
private Inner inner = null;
public Outter() {
}
public Inner getInnerInstance() {
if(inner == null)
inner = new Inner();
return inner;
}
class Inner {
public Inner() {
}
}
}
内部类可以拥有private访问权限、protected访问权限、public访问权限及包访问权限。比如上面的例子，如果成员内部类Inner用private修饰，则只能在外部类的内部访问，如果用public修饰，则任何地方都能访问；如果用protected修饰，则只能在同一个包下或者继承外部类的情况下访问；如果是默认访问权限，则只能在同一个包下访问。这一点和外部类有一点不一样，外部类只能被public和包访问两种权限修饰。我个人是这么理解的，由于成员内部类看起来像是外部类的一个成员，所以可以像类的成员一样拥有多种权限修饰
局部内部类
局部内部类是顶一个方法或者一个作用域里面的类
与成员内部类的区别：局部内部类的访问仅限于方法内或者该作用域内。
class People{
public People() {
}
}
class Man{
public Man(){
}
public People getWoman(){
class Woman extends People{ //局部内部类
int age =0;
}
return new Woman();
}
}
局部内部类就像方法里面的一句不变量一样，是不能有public protected private 以及static修饰符的
匿名内部类
- 使用匿名内部类时候，必须继承一个类或者实现一个接口
- 匿名内部类没有名字，所以不能定义构造函数
- 匿名内部类不能含有静态成员变量和静态方法。
- 匿名内部类也是不能有访问修饰符和static修饰符的。
public abstract class Bird {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public abstract int fly();
}
public class Test {
public void test(Bird bird){
System.out.println(bird.getName() + "能够飞 " + bird.fly() + "米");
}
public static void main(String[] args) {
Test test = new Test();
test.test(new Bird() {
public int fly() {
return 10000;
}
public String getName() {
return "大雁";
}
});
}
}
静态内部类
静态内部类也是定义在另一个类里面的类，只不过在类前面加了一个关键字static。静态内部类是不需要依赖于外部类的，这点和类的静态成员属性有点类似，并且它不能使用外部类的非static成员变量或者方法。
public class Test {
public static void main(String[] args) {
Outter.Inner inner = new Outter.Inner();
}
}
class Outter {
public Outter() {
}
static class Inner {
public Inner() {
}
}
}
class Outter{
int a=10;
static int b=5;
static int b=5;
public Outter(){
}
static class Inner{
public Inner(){
System.out.println(==a==);//报错 静态内部类不能引用非static成员对象
System.out.println(b);
}
}
}