08 Java程序员面试宝典视频课程之内部类

一、方法内部能不能定义类?
答:
可以，是方法内部类

二、说出定义内部类的方式?
答:
A、成员内部类：
1、定义在另一个类(外部类)的内部,与成员方法和属性平级，属于类
的一个成员，可以用 private,defelet，protected,public 四个访问修饰符修饰
2、外部类无法直接访问成员内部类的方法和属性，需要通过内部类的一个实例来访问。
调用方式：
外部类名.内部类名 实例名 = 外部类实例名.new 内部类构造方法(参数)。

 public class Person {
    private String name;
    public class Son{
        private int age;
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
    }
//属性name的get set方法
/**
 调用方法
*/
public static void main(String[] args) {
    Person p = new Person();
    Person.Son son=p.new Son();
               son.setAge(234);
        System.out.println(son.getAge());
    }
    }

B、静态内部类：
static 修饰的成员内部类叫静态内部类(嵌套类)
调用方式：
外部类名.内部类名 实例名 = new 外部类名.内部类名(参数)。

public class Son {
  private  String name;
  /**
   静态内部类
  */
public static  class Terll{
    private static int age;
    public static int getAge() {
        return age;
    }
    public static void setAge(int age) {
        Terll.age = age;
    }
}
/**
 调用的方法
*/
public static void main(String[] args) {
       Son.Terll terll = new Son.Terll();
                  terll.setAge(23);
        }
    //name属性的get set 方法
    }

C、局部内部类：
1、定义在代码块或方法体内的类叫局部内部类。局部内部类只能在代码块和方法体内使用;

public class Son {
  private  String name;
  /**
   * 在方法体中定义内部类
   * */
  public String getName() {
      //局部内部类
      class Terll{
            private int age;
            public int getAge() {
                return age;
            }
            public void setAge(int age) {
                this.age = age;
            }
      }
        return name;
    }   }

D、匿名内部类：
1、特殊的局部内部类;
2、只能使用一次，创建实例之后，类定义会立即消失;
3、必须继承一个类（抽象的、非抽象的都可以）或者实现一个接口;并匿名内部类必须实现其所有抽象方法。
4、匿名内部类不能是抽象类，因为匿名内部类会立即创建一个实例
5、匿名内部类不能定义构造方法，匿名内部类没有类名，但是匿名内部类
拥有父类所有构造方法
6、可以定义代码块，用于实例的初始化。

abstract class User {
 public abstract  void  Person();
}
public class ColorTxt {
/**
匿名内部类
*/
    public static void main(String[] args) {    
        User us = new User(){
            {
                System.out.println("我是冥名内部类");
            }
            @Override
            public void Person() {
            }
            };
    }
}

三、普通成员内部类能不能直接访问外部类的普通成员?
答:
可以直接访问外部类的成员

 public class Person {
    private String name;
    public class Son{
        private int age;
        public void tell(){
            System.out.println("外部类"+name);
        }
        //内部类的get set方法
        }
                //外部类的get set方法和构造方法
            }   
            /**
             执行
            */
    public static void main(String[] args) {
    Person p = new Person("我是外部类");
    Person.Son son=p.new Son();
               son.setAge(234);
               son.tell();
    }

四、静态成员内部类能不能直接访问外部类普通成员?能不能访问外部类静态成员?
答:
1.不能访问外部类的非静态成员（变量或者方法）。
2.可以访问外部类的静态成员或者方法。

public class Son {
public static String names;
private String name;
public static class Terll{
public void My(){
System.out.println(names+getAge());
} }
//外部类的get set 方法
//调用的方法
public static void main(String[] args) {
Son.setNames(“我是外部类的静态方法”);
Son.Terll terll = new Son.Terll();
terll.My();
}
}
五、什么时候会使用匿名内部类?
答:
类创建对象一次后再也不使用了,就可以使用匿名内部类。