黑马程序员 java_内部类，object

最新推荐文章于 2024-10-22 15:51:09 发布

原创最新推荐文章于 2024-10-22 15:51:09 发布 · 106 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #移动开发

日志专栏收录该内容

32 篇文章

订阅专栏

本文深入讲解Java内部类的概念、特点及应用场景，包括内部类如何访问外部类成员、不同类型的内部类及其访问规则，并探讨内部类解决多重继承问题的优势。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

内部类

可以将一个类的定义放在另一个类的内部,这就是内部类。

内部类是一个非常有用的特性,它允许把一些逻辑相关的类组织在一起,并控制位于内部的可性。

class Outer
{	private int x = 3;
	class Inner//内部类
	{
		//int x = 4;
		void function()
		{
			//int x = 6;
			System.out.println("innner :"+Outer.this.x);
		}
	}
	void method()
	{
		Inner in = new Inner();
		in.function();
	}
}
class  InnerClassDemo
{
	public static void main(String[] args) 
	{
		Outer out = new Outer();
		out.method();
		//直接访问内部类中的成员。
//		Outer.Inner in = new Outer().new Inner();
//		in.function();
	}
}

Inner就是一个内部类，Outer是一个外部类。

内部类产生的原因

package itcast.heima;

class D{}
abstract class E{}

class Z extends D{
	E makeE(){
		return new E(){};
	}
}

public class TestDemo {
	static void takesD(D d){}
	static void takesE(E e){}
	public static void main(String[] args) {
		Z z = new Z();
		takesD(z);
		takesE(z.makeE());
	}

}

此处类Z中的，new E(){}就是一个内部类。如果不这样定义，而是通过外部类Z来实现。类Z就得同时继承D和E，这在语法上就是错误的。所以说内部类解决了“多重继承” 的问题。

好处在于：每个内部类都能独立的继承一个接口或实现，而不用担心外部类是否已经继承了某个接口或实现。并且一个外部类中可以同时有多个内部类，这些内部类相互独立，各有各的属性和行为，同时它们都能调用外部类的信息。

内部类的访问规则

1，内部类可以直接访问外部类中的成员，包括私有。之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式为外部类名.this。

2，外部类要访问内部类，必须建立内部类对象。

内部类的访问格式

1，当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中。可以直接建立内部类对象。

格式：外部类名.内部类名变量名 = 外部类对象.内部类对象;

Outer.Inner in = new Outer().new Inner();

2，当内部类在成员位置上，就可以被成员修饰符所修饰。

private：将内部类在外部类中进行封装。

static：内部类就具备static的特性。当内部类被static修饰后，只能直接访问外部类中的static成员。出现了访问局限。

在外部其他类中，访问static内部类的非静态成员

new Outer.Inner().function();

在外部其他类中访问static内部类的静态成员

Outer.Inner.function();

注意：当内部类中定义了静态成员，该内部类必须是static的。

当外部类中的静态方法访问内部类时，内部类也必须是static的。

当描述事物时，事物的内部还有事物，该事物用内部类来描述。

因为内部事务在使用外部事物的内容。

3，内部类定义在局部时

(A) 不可以被成员修饰符修饰，因为成员修饰符只能修饰成员，而不能修饰局部。

(B) 可以直接访问外部类中的成员，因为还持有外部类中的引用。但是不可以访问它所在的

局部中的变量。只能访问被final修饰的局部变量。

class Outer
{
	int x = 3;

	void method(final int a)
	{
		final int y = 4;//y被final修饰。
		class Inner
		{
			void function()
			{
				System.out.println(y);//y已被final修饰。可以被内部类调用。
			}
		}
	
		new Inner().function();
		
	}
}

匿名内部类

1，匿名内部类其实就是内部类的简写格式。

2，定义匿名内部类的前提：内部类必须是继承一个类或者实现接口。

3，匿名内部类的格式： new 父类或者接口(){定义子类的内容}

4，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖，可以理解为带内容的对象。

5，匿名内部类中定义的方法最好不要超过3个。

interface Inter
{
	void method();
}

class Test 
{
	
	static Inter function()
	{

	       //匿名内部类,new Inter(){}相当于一个实现了Inter接口的类的对象
		return new Inter()
		{
			public void method()
			{
				System.out.println("method run");
			}
		};
	}

}

一个特殊的匿名类，new Object(){},没有父类或已实现的接口，只是因为类 Object 是类层次结构的根类。

class InnerTest
{

	public static void main(String[] args)
	{
		new Object()
		{
			public void function()
			{
				
			}
			
		}.function();


	}
}

Object

Object:是所有对象的直接后者间接父类，传说中的上帝。

该类中定义的肯定是所有对象都具备的功能。

Object类中已经提供了对对象是否相同的比较方法。

如果自定义类中也有比较相同的功能，没有必要重新定义。只要沿袭父类中的功能，建立自己特有比较内容

即可，这就是覆盖。

class Demo //extends Object
{
	private int num;
	Demo(int num)
	{
		this.num = num;
	}
	
	public boolean equals(Object obj)//Object obj = new Demo();
	{

		if(!(obj instanceof Demo))
			return false;
		Demo d = (Demo)obj;

		return this.num == d.num;
	}
	
	
	public String toString()
	{
		return "demo:"+num;
	}


}

Object类中已存在equals方法，通过比较两个对象的地址值，来判断这两个对象是否相等。

而Demo类中的equals方法是覆盖了Object中的equals，通过比较两个对象的num属性，来判断两个对象是否相等。

此外Object中还要toString方法，hashCode，wait等常用方法。无论新创建一个什么类型的类，都会自动的从Object中获取到这些方法，但我们需要使用这些方法是，直接拿来用即可，如果需要在这些自定义方法，覆盖即可。

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------