Java内部类

曹MX

于 2021-08-12 19:16:06 发布

阅读量74

点赞数

本文链接：https://blog.csdn.net/weixin_50736421/article/details/119651727

版权

内部类

内部类：在一个类的内部又定义了一个类，称为内部类，外面的称为外部类

内部类：成员内部类、静态内部类、局部内部类、隐匿内部类

1、成员内部类

使用场景：类中的一个组成部分又是一个类

【说明】成员内部类中不能声明静态成员

package com.qf.pro2103.day14;

public class Outer {
	//属性
	private String name="张三";
	private int age;
	public void test(){
		System.out.println("我是外部类中的test()方法");
	}
	//成员内部类
	class Inner{
		//内部类成员
		private String address="辽宁省大连市";
		private String phone="0411-88";
		private String name="李四";
		//方法
		public void show(){
			//访问外部类中的成员
			System.out.println(Outer.this.name);
			System.out.println(Outer.this.age);
			Outer.this.test();
			//访问内部类的成员
			System.out.println(this.address);
			System.out.println(this.phone);
			System.out.println(this.name);
		}
	}
}

package com.qf.pro2103.day14;

import com.qf.pro2103.day14.Outer.Inner;

public class TestOuter {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建外部类对象
		Outer outer=new Outer();
		outer.test();
		//创建内部类对象,如果访问内部类成员，那么必须创建内部类对象
		//方式1：通过外部类对象来创建内部类对象
		Inner inner=outer.new Inner();
		//方式2：一步完成
		Inner inner2=new Outer().new Inner();
		inner.show();
		inner2.show();
		
	}

}

2、静态内部类和成员内部类的区别

1、在静态内部类中可以生命静态成员

2、在静态内部类中访问外部类的实例成员时，不能直接访问，必须创建外部类对象，通过对象访问

3、创建内部类对象方式不同

成员内部类： Inner inner2=new Outer().new Inner();

静态内部类: Outer.Inner inner=new Outer.Inner();

package com.qf.pro2103.day14.staticinnerclass;

public class Outer {
	private String name;
	private int age;
	public void test(){
		System.out.println("我是外部类的test()方法");
	}
	//静态内部类
	static class Inner{
		//成员
		private String address="辽宁省大连市";
		private String phone="0411-88888888";
		//可以声明静态成员
		private static int count=100;
		public void show(){
			//静态成员不能直接访问实例成员,可以直接访问静态的成员
			//实例成员可以直接访问实例成员，也可以直接访问静态成员
			//如果要访问外部类成员---new
			Outer outer=new Outer();
			outer.name="贾玉堃";
			outer.age=20;
			System.out.println(outer.name);
			System.out.println(outer.age);
			System.out.println(this.address);
			System.out.println(phone);
			System.out.println(Inner.count);
		}
	}
}

package com.qf.pro2103.day14.staticinnerclass;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Outer outer=new Outer();
		//访问外部类成员
		outer.test();
		
		//访问静态内部类成员
		Outer.Inner inner=new Outer.Inner();
		inner.show();

	}

}

3、局部内部类

在方法中或方法的语句块中编写的类

package com.qf.pro2103.day14.local;

public class Outer {
	private String name="贾玉堃";
	private int age=20;
	public void show(final int i){
		//局部常量i在赋值后就不能改变其值
		//声明局部变量
		String address="辽宁省大连市";
		//局部内部类
		class Inner{
			//局部内部类的属性
			private String phone="0411-88888888";
			private String email="jiayukun@qq.com";
			//private  static int count=100;
			public void show2(){
				//String address="吉林省长春市";
				//访问外部类的属性
				System.out.println(Outer.this.name);
				System.out.println(Outer.this.age);
				//访问内部类的属性
				System.out.println(this.phone);
				System.out.println(this.email);
				//在jdk1.7中，局部内部类访问的局部变量必须是final修饰的
				//在jdk1.8开始，局部变量默认具有final
				//address="黑龙江省哈尔滨市";
				System.out.println(address);
				
			}
		}
		//创建局部内部类对象---一定要在内部类的有效作用域内创建
		Inner inner=new Inner();
		inner.show2();
	}
}

package com.qf.pro2103.day14.local;

public class Test {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Outer outer=new Outer();
		outer.show(10);
	}

}

package com.qf.pro2103.day14.noname;

public interface Usb {
	void service();
}

package com.qf.pro2103.day14.noname;

public class TestUsb {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Usb mouse=new Usb(){
			//{}里的就是匿名内部类,此匿名内部类是Usb接口的实现类
			@Override
			public void service() {
				// TODO Auto-generated method stub
				System.out.println("我是Usb鼠标！");
			}
			
		};
		Usb keyBord=new Usb(){

			@Override
			public void service() {
				// TODO Auto-generated method stub
				System.out.println("我是Usb键盘！");
			}
			
		};
		
		mouse.service();
		keyBord.service();
	}

}

4、隐匿内部类

没有名字的内部类，通常和接口一起配合使用

Object

在java继承结构中Object类是所有类的默认父类，新建一个类后，默认继承Object

API：应用程序接口系统类

对象：getClass（）

返回的类型是Class ，代表对象的实际类型

package com.qf.pro2103.day14;

public class Demo2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student jiayukun=new Student();
		Student ha=new Student();
		Class clazz1=jiayukun.getClass();
		Class clazz2=ha.getClass();
		System.out.println(clazz1==clazz2);
	}

}

hashCode（）

返回的是地址的，字符串的，整型值的十进制整数值，是java根据哈希算法计算出的一个值

【说明】同一个地址、字符串、整型值的哈希值是固定的

相同对象返回相同的哈希值，确保不同对象返回不同的哈希值—需要重写hashCode()

package com.qf.pro2103.day14;

public class Demo3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student zhang=new Student();
		int zhangHashCode=zhang.hashCode();
		String xiaoZhang="张磊";
		System.out.println(zhangHashCode);
		System.out.println(xiaoZhang.hashCode());
		Student jia=zhang;
		System.out.println(jia.hashCode());
	}	

}

toString（）

String类重写了Object中的toString()

toString() 以字符串形式返回值

当new出一个对象后，默认情况下对象中存放的是地址，当重写了toString（）方法后，当获取对象时得到的是toString()里返回的内容，通过对象访问成员时，使用的还是引用。

package com.qf.pro2103.day14;

public class Student {
	
	public Student() {
		super();
	}
	
	public Student(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	public String toString(){
		return "name="+this.name+",age="+this.age;
	}
	private String name;
	private int age;
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public void show(){
		System.out.println("我是学生："+this.name);
	}
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
}

package com.qf.pro2103.day14;

public class Demo5 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Student[] ary=new Student[3];
		ary[0]=new Student("吴亦凡",31);
		ary[1]=new Student("张艺兴",28);
		ary[2]=new Student("鹿晗",29);
		for(int i=0; i<ary.length; i++){
			//默认输出的是对象的地址，如果重写了toString()那么输出toString里的内容
			System.out.println(ary[i]);
		}
	}

}