JavaSE基础六（抽象类与接口）

文章目录

• • 内部类
  • • 1.1 内部类概述
    • 1.2 成员内部类
    • 1.3 局部内部类
    • 1.4 匿名内部类
    • 1.5 匿名内部类在开发中的使用

内部类

1.1 内部类概述

内部类：就是在一个类中定义一个类。举例：在一个类A的内部定义一个类B，类B就被称为内部类

内部类的定义格式：

• 格式：

public class 类名{
     修饰符 class 类名{
        
    }
}
           

• 范例：

public class Outer{
    public class Inner{
        
    }
}
           

内部类的访问特点

• 内部类可以直接访问外部类的成员，包括私有
• 外部类要访问内部类的成员，必须创建对象

/*
	内部类的访问特点

- 内部类可以直接访问外部类的成员，包括私有
- 外部类要访问内部类的成员，必须创建对象
 */
public class Outer {
	private int num = 10;
	public class Inner{
		public void show(){
			System.out.println(num);//内部类可以直接访问外部类的成员，包括私有
		}
	}
	public void method(){
		Inner i = new Inner();
		i.show();//外部类要访问内部类的成员，必须创建对象
	}

}
           

1.2 成员内部类

按照内部类在类中定义的位置不同，可以分为如下两种形式

• 在类的成员位置：成员内部类
• 在类的局部位置：局部内部类

成员内部类外界如何创建对象使用呢？

• 格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象；

/*测试类*/
public class InnerDemo {
	public static void main(String[] args) {
		Outer.Inner io = new Outer().new Inner();
		io.show();
	}
}
           

如果内部类中使用private修饰的话，如何访问

public class Outer {
	private int num = 10;
	private class Inner{
		public void show(){
			System.out.println(num);//内部类可以直接访问外部类的成员，包括私有
		}
	}
	public void method(){/*在method方法中创建了这个内部类的对象，并调用了它的方法
	然后在测试类中，只需要创建外部类的对象，调用method方法就可以，就可以间接的访问了
	内部类中的方法了*/
		Inner i = new Inner();
		i.show();//外部类要访问内部类的成员，必须创建对象
	}
}
-------------------
public class InnerDemo {
	public static void main(String[] args) {
		/*Outer.Inner io = new Outer().new Inner();
		io.show();*/
		Outer outer = new Outer();
		outer.method();
	}
}    
           

1.3 局部内部类

局部内部类的是在方法中定义的类，所以外界是无法直接使用的，需要在方法内部中创建内部类对象并使用，该类可以直接访问外部类的成员，也可以访问该方法的局部变量。

public class Outer{
    private int num = 10;
    
    public void method(){
        int num2 = 33;//定义一个局部变量
        class Inner{
            public void show(){
                System.out.println(num);
                System.out.println(num2);

            }
        }
        Inner i = new Inner();/*在方法的内部，创建局部内部类的对象用来调用*/
        i.show();
    }   
}
-----------------------
public class OuterDemo{
    public static void main(String[] arsg){
        Outer o = new Outer();
        o.method();
    }
}
           

1.4 匿名内部类

前提：存在一个类或者接口，这里的类可以是具体类也可以是抽象类

• 格式：

new 类名或者接口名(){
  		重写方法;  
};//看作成匿名对象
           

• 范例：

new Inner(){
    	public void show(){
            
        }
};
           

本质：是一个继承了一个类或者实现了该接口的子类匿名对象

/*
	这是匿名内部类，需要的接口
* */
public interface Inter {
	void show();
}
---------------------
public class Outer {
	public void method(){
		/*new Inter(){
			@Override
			public void show() {
				System.out.println("匿名内部类！");
			}
		};*/
	/*	new Inter(){
			@Override
			public void show() {
				System.out.println("匿名内部类！");
			}
		}.show();
		new Inter(){
			@Override
			public void show() {
				System.out.println("匿名内部类！");
			}
		}.show();*/
		Inter i = new Inter(){
			@Override
			public void show() {
				System.out.println("匿名内部类！");
			}
		};
		i.show();//多次调用
		i.show();
	}
}
------------------------
public class OuterDemo {
	public static void main(String[] args) {
		Outer o = new Outer();
		o.method();
	}
}
------------
匿名内部类！
匿名内部类！    
           

1.5 匿名内部类在开发中的使用

/*
	跳高接口
*/
public interface Jumpping{
    	void jump();
}
           

/*
	接口操作类，里面有一个方法，方法的参数就是接口名
*/
public class JumppingOperator{
    public void method(Jumpping j){//方法的形参是接口名，其实要的是该接口的实现类对象
        j.jump();
    }
}
           

/*
	测试类
*/
public class JumppingDemo{
    public static void main(String[] arsg){
        //需求：创建接口操作类的对象，调用method方法
    }
}
           

/*
	接口
 */
public interface Jumpping {
	void jump();
}
------------------------
/*
	接口操作类，
 */
public class JumppingOperator {

	public void method(Jumpping j){//方法的形参是接口名，其实要的是该接口的实现类对象
		j.jump();
	}
}    
-------------------
/*
		接口的实现类Cat
 */
public class Cat implements Jumpping {
	@Override
	public void jump() {
		System.out.println("猫可以跳高了");
	}
}
------------------
/*
	测试类
 */
public class JumppingDemo {
	public static void main(String[] args) {
		//创建接口操作类的对象，调用method方法
		JumppingOperator jo = new JumppingOperator();
		Jumpping j = new Cat();
		jo.method(j);


		Jumpping j2 = new Dog();
		jo.method(j2);

		jo.method(new Jumpping() {
			@Override
			public void jump() {
				System.out.println("匿名内部类直接添加");
			}
		});

		jo.method(new Jumpping() {
			@Override
			public void jump() {
				System.out.println("猪都可以起飞了！");
			}
		});
	}
}