----------- 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学习型技术博客、期待与您交流！ ------------