Java面向对象 Object类 内部类



Java面向对象 Object类    内部类

知识概要：

                一：Object类

                二：内部类 匿名内部类的写法

1.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;
	}

}
class Person
{
}

class ObjectDemo
{
	public static void main(String[] args)
	{
		Demo d1 = new Demo(4);
		System.out.println(d1);//输出语句打印对象时，会自动调用对象的toString方法。打印对象的字符串表现形式。
		Demo d2 = new Demo(7);
		System.out.println(d2.toString());
		//Demo d2 = new Demo(5);
		//Class c = d1.getClass();
//
//		System.out.println(c.getName());
//		System.out.println(c.getName()+"@@"+Integer.toHexString(d1.hashCode()));
//		System.out.println(d1.toString());
		//Person p = new Person();
		///System.out.println(d1.equals(p));

	}
}

2.内部类：

将一个类定义在另一个类的里面，对里面那个

       类就称为内部类（内置类，嵌套类）。

   访问特点：

       • 内部类可以直接访问外部类中的成员，包括私有成员。

• 而外部类要访问内部类中的成员必须要建立内部类的对象。

内部类的位置

内部类定义在成员位置上

• 可以被private static成员修饰符修饰。

        • 被static修饰的内部类只能访问外部类中的静态成员。

     内部类定义在局部位置上

        • 也可以直接访问外部类中的成员。

        • 同时可以访问所在局部中的局部变量，但必须是被final修饰的。

  匿名内部类

  就是内部类的简化写法。

 

前提：

      • 内部类可以继承或实现一个外部类或者接口。

  格式为：

      • new 外部类名或者接口名(){覆盖类或者接口中的代码，(也可以自定义内容。)}

 简单理解：

      • 就是建立一个建立一个带内容的外部类或者接口的子类的匿名对象。

class Outer
{
	private int x = 3;

	class Inner//内部类
	{
		//int x = 4;
		void function()
		{
			//int x = 6;
			System.out.println("innner :"+Outer.this.x);//若打印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();
	}
}

访问格式：

       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的。

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

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

/*
内部类定义在局部时，
1，不可以被成员修饰符修饰
2，可以直接访问外部类中的成员，因为还持有外部类中的引用。
	但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。
*/
class Outer
{
	int x = 3;

	void method(final int a)
	{
		final int y = 4;
		class Inner
		{
			void function()
			{
				System.out.println(y);
			}
		}

		new Inner().function();

	}
}

class  InnerClassDemo3
{
	public static void main(String[] args)
	{
		Outer out = new Outer();
		out.method(7);
		out.method(8);
	}

}