java的四种内部类,从0讲清楚

什么是内部类?

java的四种内部类,从0讲清楚_第1张图片

java的四种内部类,从0讲清楚_第2张图片

为什么要学习内部类?

可以发现,发动机虽然跟汽车相关,但发动机不像车龄或颜色一样,只用一个变量就可以描述,而是要有发动机品牌,发动机年限,多个变量描述发动机。那么这样写Car类是不合适的

java的四种内部类,从0讲清楚_第3张图片

所以要用上内部类描述发动机

java的四种内部类,从0讲清楚_第4张图片

内部类的访问特点

1.内部类可以直接访问外部类,包括私有

2.外部类要访问内部类,必须创建对象

这里的this指针用法要复习一下,

如果Car.this没写,this.carName直接写成carName也是没错的,因为就算不写编译器也会自动添加this关键字。这个过程被称为隐式引用。

java的四种内部类,从0讲清楚_第5张图片

内部类的分类

java的四种内部类,从0讲清楚_第6张图片

成员内部类

举个例子

可以看到,我们把内部类理解当成成员属性就好了。

java的四种内部类,从0讲清楚_第7张图片

1.成员内部类的修饰符

着重介绍一个,private修饰成员内部类,怎么理解呢?

把他当成成员变量一样就好了。即只能在类内(Car类里)访问,只能在外部类内实例化对象(比如说第二个红框的位置),外部类以外是操作不到的

java的四种内部类,从0讲清楚_第8张图片

那如果用static修饰成员内部类呢?实际上这就叫静态内部类了,后面会介绍

2.获取成员内部类的对象

实例化方法1:

class Outer{
	class Inner{
		;
	}
	
}

public class Main {
	
	public static void main(String[] args) {
		Outer o = new Outer();
		Outer.Inner io1 = o.new Inner();
		
		//可以简写成这样
		Outer.Inner io2 = new Outer().new Inner();
		
   }
}

实例化方法2:

如果成员内部类是私有的,外部就访问不到了,就不能用方法1来实例化对象

java的四种内部类,从0讲清楚_第9张图片

要怎么改呢?写一个对外提供内部类的方法

class Outer{
	private class Inner{
		;
	}
	
	public Inner getInner() {//对外提供Inner
		return new Inner();
	}
	
}

如何接收呢?

这样是错的

java的四种内部类,从0讲清楚_第10张图片

下面是对的

java的四种内部类,从0讲清楚_第11张图片

或者直接使用也可以。此处打印的是地址

静态内部类

java的四种内部类,从0讲清楚_第12张图片

1)注意:静态内部类只能访问外部类中的静态变量和静态方法,如果想要访问非静态的,需要创建对象。

2)创建静态内部类的格式:外部类名.内部类名 对象名 = new 外部类名.内部类名()。因为是静态的,所以就不用先创建一个外部类对象,再创建内部类。

如何调用静态内部类中的方法?

3)调用非静态方法的格式:先创建内部类的对象,用对象调用

4)调用静态方法的格式:外部类名.内部类名.方法名()

只要是静态的东西,都可以用类名点直接获取!

对于(1)

class Outer{
	int a = 10;
	static int b = 20;
	
	static class Inner{
		public void show1() {
			
			System.out.println(new Outer().a);//此时是报错的,因为不能直接访问非静态的变量
			System.out.println(b);//但是b可以,因为b是静态的
		}
		
		static public void show2() {
			System.out.println(new Outer().a);
			System.out.println(b);
		}
		
	}
	
}


public class Main {
    public static void main(String[] args){
    	Outer o = new Outer();
    	Outer.Inner io = new Outer.Inner();
    	io.show1();
    	Outer.Inner.show2();
    	
    	
    }
  
}

局部内部类

1)将内部类定义在方法里就叫局部内部类,类似与方法里的局部变量

2)外界是无法直接使用的,要在方法内部创建并调用。

3)该类可以直接访问外部类的成员,也可以访问方法内的局部变量

class Outer{
	int a = 10;
	void show() {
		int b = 20;
		class Inner{//注意!把局部内部类当成局部变量就行了!
			        //public等修饰符不能修饰局部变量,那么也不能修饰局部内部类
			public void test1() {
				System.out.println(a);
				System.out.println(b);
			}
			
		}
		Inner i = new Inner();
		i.test1();
		
	}
	
}


public class Main {
    public static void main(String[] args){
    	Outer o = new Outer();
    	o.show();
    	
    	
    }
  
}

匿名内部类

怎么写匿名内部类?

java的四种内部类,从0讲清楚_第13张图片

interface Swim{
	public void swim();
}

abstract class Animal{
	abstract void eat();
}



public class Solve {
	public static void main(String[] args) {
		
		//编写匿名内部类代码
		
		new Swim(){//Swim是接口,这里是实现关系
			public void swim() {
				System.out.println("重写swim");
			}
		};
		
		new Animal() {//Animal是类,这里是继承关系

			@Override
			void eat() {
				// TODO Auto-generated method stub
				System.out.println("重写eat");
			}
			
		};
		
		
	}
	
}

进一步了解什么是匿名内部类

实际上,红圈内的内容才是匿名内部类,因为它是没有名字的。

而蓝圈在做的是是创建一个匿名内部类

java的四种内部类,从0讲清楚_第14张图片

为什么要学习匿名内部类?


class Animal{
	void shout() {}
}
class Dog extends Animal{

	@Override
	void shout() {
		// TODO Auto-generated method stub
		System.out.println("dog is barking");
	}
	
}



public class Main {
	public static void method(Animal a) {//多态
		a.shout();
	}

    public static void main(String[] args){
    	//假设我们现在要调用method函数实现dog的行为,该怎么办呢?
    	//以前的方法:
    	//创建一个狗的类,实例化一个狗的类,类内重写方法
    	Dog d = new Dog();
    	method(d);
    	
    	//以前的方法有点麻烦,因为如果我们只需要使用一次dog,那么单独再写一个Dog类就太麻烦了
    	//所以可以用匿名内部类,用完一次就丢。
    	//跟以前的办法相比,这个只要重写并创建匿名对象就行了
    	method(
    			new Animal(){
    				void shout() {
    					System.out.println("dog2 is barking");
    				}
    			}
    			
    			
    	);
    	
    }
}

匿名内部类的一些实用小技巧

1.创建的对象可以被接收

class Animal{
	void shout() {}
}




public class Main {
	public static void method(Animal a) {//多态
		a.shout();
	}

    public static void main(String[] args){
    	
    	//我们知道,new Animal()其实是创建对象的过程,只不过是匿名的
    	//那么我们可不可以用一个对象来接收呢?可以!
    	//那这样有什么好处呢?
    	//这样我们就不用单独再写一个Dog类,省去了不必要的类,
    	//而且调用比上一段代码更灵活(个人感觉)
    	Animal a =  new Animal(){
    		//注意,因为经过重写,所以实际上是创建了一个子类的对象
    		//但这里用父类的对象接收,所以这里也是多态!
			void shout() {
				System.out.println("dog is barking");
			}
		};
    	
		method(a);
		method(a);
		method(a);
    	//...
		//想用几次就用几次,代码比上一段简洁一些
    			
    	
    }
}

2.直接调用方法

public class Main {
	

    public static void main(String[] args){	
    	new Animal(){
			void shout() {
				System.out.println("dog is barking");
			}
		}.shout();//还可以这样去调用方法
    	
		
    			
    	
    }
}

小结

java的四种内部类,从0讲清楚_第15张图片

你可能感兴趣的:(java,开发语言)