如果一个事物的内部包含另一个事物，那就是一个类内部包含另一个类
分类:
1、成员内部类
2、局部内部类，包含匿名内部类
成员内部类的定义格式
修饰符 class 类名称{
修饰符 class 内部类名称{
//..
}
//..
}
注意： 内用外，随意使用，外用内，需要内部类对象
1、内部类的概念与分类
成员内部类
局部内部类：包括匿名内部类
2、成员内部类的定义
3、成员内部类的使用
1、间接方式：在外部类的方法中，使用内部类，然后main只是调用外部类的方法
2、直接方法：
类名称 对象名 = new 类名称()
外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
主类
package cn.day11.demo03;
/*
如果一个事物的内部包含另一个事物，那就是一个类内部包含另一个类
分类:
1、成员内部类
2、局部内部类，包含匿名内部类
成员内部类的定义格式
修饰符 class 类名称{
修饰符 class 内部类名称{
//..
}
//..
}
注意： 内用外，随意使用，外用内，需要内部类对象
*/
public class Demo01InnerClass {
public static void main(String[] args) {
Body body = new Body();
//间接：通过外部类的对象，调用外部类的方法，里面间接使用内部类Heart
body.methodBody();
/*
结果
外部类的方法
心脏跳动
我叫：null
*/
System.out.println("==========");
//直接,按照公式
Body.Heart bodyheart = new Body().new Heart();
bodyheart.beat();
/*
心脏跳动
我叫：null
*/
}
}
内部类
package cn.day11.demo03;
public class Body { //外部类
public class Heart{ //成员内部类
public void beat(){
System.out.println("心脏跳动");
System.out.println("我叫：" + name);
}
}
public void methodBody(){
System.out.println("外部类的方法");
new Heart().beat();
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
private String name;
}
4、内部类的同名变量访问
内部类
package cn.day11.demo03;
public class Outer {
int num = 10;
public class Inner{
int num = 20;
public void Inner(){
int num =30;
System.out.println(this.num); //20
System.out.println(num); //30
System.out.println(Outer.this.num); //10
}
}
}
主方法：
package cn.day11.demo03;
public class Demo02InnerClass {
public static void main(String[] args) {
//外部类名称.内部类名称 对象名 = new 外部类名称().new 内部类名称();
Outer.Inner inner = new Outer().new Inner();
inner.Inner();
/*
20
30
10
*/
}
}
5、局部内部类的定义
如果一个类是定义在一个方法内部的，就是一个局部内部类，
局部：只有当前所属方法能使用它，出了方法外面就不能用
定义格式：
修饰符 class 外部类名称{
修饰符 返回值类型 方法名(){
class 局部内部类名称{
// ..
}
}
}
小节权限修饰符：
public > protected > (default) > private
定义一个类的时候，权限修饰符
1、外部类：public protected
2、成员内部类： 都行
3、局部内部类：什么都不写
局部内部类
package cn.day11.demo04;
public class Outer {
public void outer(){
class Inner{ //局部内部类,只有当前方法outer可以访问
int num =10;
public void Inner(){
System.out.println(num); //10
}
}
Inner inner = new Inner();
inner.Inner();
}
}
主方法
package cn.day11.demo04;
public class Demomain {
public static void main(String[] args) {
Outer outer = new Outer();
outer.outer(); //10
}
}
6、匿名内部类，很重要哦
如果接口的实现类，或者父类的子类，只需要使用唯一一次，就可以省略掉该类的定义，用匿名内部类，
匿名内部类的定义格式：
接口名称 对象名 = new 接口名称{
//覆盖重写接口的抽象方法
}
接口
package cn.day11.demo05;
public interface MyInterface {
void method(); //抽象方法
}
实现类： 使用匿名内部类，就为了省略这货
package cn.day11.demo05;
public class MyInterfaceImpl implements MyInterface{
@Override
public void method() {
System.out.println("实现类覆盖重写了方法");
}
}
主方法：
package cn.day11.demo05;
/*
如果接口的实现类，或者父类的子类，只需要使用唯一一次，就可以省略掉该类的定义，用匿名内部类，
匿名内部类的定义格式：
接口名称 对象名 = new 接口名称{
//覆盖重写接口的抽象方法
}
*/
public class DemoMain {
public static void main(String[] args) {
MyInterfaceImpl myInterface = new MyInterfaceImpl();
MyInterface impl = new MyInterfaceImpl(); //多态的写法，左父右子
myInterface.method(); //实现类覆盖重写了方法
impl.method(); //实现类覆盖重写了方法
//MyInterface myInterface1 = new MyInterface(); 错误写法
// 匿名内部类, 省掉一个实现类的单独定义。简单
MyInterface myInterface1 = new MyInterface() { //大括号是一个局部内部类， 又没有名字。所以这一块叫匿名内部类，实现了接口
@Override
public void method() {
System.out.println("匿名内部类实现类方法") ;
}
};
myInterface1.method();
}
}
7、匿名内部类的注意事项
对格式 new 接口名称(){..}解析
1、new 代表创建对象的动作
2、接口名称就是匿名内部类需要实现哪个接口
3、{...}这才是匿名内部类的内容
注意几点问题：
1、匿名内部类，在创建对象的时候，只能使用唯一一次
如果希望多次创建对象，而且类的内容一样的话，那么必须使用单独定义的实现类
2、匿名对象，在调用方法的时候， 只能调用唯一一次
如果希望同一个对象，调用多次方法，那么必须给对象起名字
3、 匿名内部类是省略了 实现类/ 子类名称，匿名对象省略对象名称
强调， 匿名内部类和匿名对象不是一回事
接口，多个方法
package cn.day11.demo05;
public interface MyInterface {
void method(); //抽象方法
void method2();
}
主方法
package cn.day11.demo05;
/*
如果接口的实现类，或者父类的子类，只需要使用唯一一次，就可以省略掉该类的定义，用匿名内部类，
匿名内部类的定义格式：
接口名称 对象名 = new 接口名称{
//覆盖重写接口的抽象方法
}
*/
public class DemoMain {
public static void main(String[] args) {
MyInterfaceImpl myInterface = new MyInterfaceImpl();
MyInterface impl = new MyInterfaceImpl(); //多态的写法，左父右子
myInterface.method(); //实现类覆盖重写了方法
impl.method(); //实现类覆盖重写了方法
//MyInterface myInterface1 = new MyInterface(); 错误写法
// 匿名内部类, 省掉一个实现类的单独定义。简单
MyInterface objA = new MyInterface() { //大括号是一个局部内部类， 又没有名字。所以这一块叫匿名内部类，实现了接口
@Override
public void method() {
System.out.println("匿名内部类实现类方法111-A") ;
}
@Override
public void method2() {
System.out.println("匿名内部类实现了方法222-A");
}
};
objA.method(); //匿名内部类实现类方法111-A
objA.method2(); //匿名内部类实现类方法222-A
//使用了匿名内部类，而且也省略了对象名称，也是匿名对象
new MyInterface() { //大括号是一个局部内部类， 又没有名字。所以这一块叫匿名内部类，实现了接口
@Override
public void method() {
System.out.println("匿名内部类实现类方法111-B") ;
}
@Override
public void method2() {
System.out.println("匿名内部类实现了方法222-B");
}
}.method(); //匿名内部类实现类方法111-B
}
}
网友评论