黑马程序员--内部类、Object类

------- android培训、java培训、期待与您交流！ ----------

内部类：

                      将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。

                  简单的说就是类中还有一个类，就是内部类。

                  字节码文件名：外部类名$内部类名.class

内部类访问特点：

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

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

           一般用于类的设计。

分析事物时，发现该事物描述中还有事物，而且这个事物还在访问被描述事物的内容。

这时就是还有的事物定义成内部类来描述。

直接访问外部类中的内部类中的成员。

外部类名.内部类名 = new 外部类对象.new 内部类对象;

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

in.method();

如果内部类是静态的。 相当于一个外部类

外部类名.内部类名 = new 外部类对象.内部类;

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

in.method();

如果内部类是静态的，成员是静态的。

外部类名.内部类名.静态函数名;

Outer.Inner.function();

                              注：如果内部类中定义了静态成员，该内部类也必须是静态的。

                               为什么内部类能直接访问外部类中成员呢？

                             那是因为内部类持有了外部类的引用。  外部类名.this

内部类可以存放在局部位置上。（也就是定义在外部类的成员函数里面，主函数也是函数哦）

内部类在局部位置上只能访问局部中被final修饰的局部变量。

class Outer { 
private Innter inner = new Outer.Inner(); 
private Outer outer = new Outer(); 
static class Inner{ 
public void run(){ 
System.out.println("Inner class run"); 
} 
public void method(){ 
System.out.println("Inner method run") 
} 
public static void show(){ 
System.out.println("Inner static show run"); 
} 
} 
public void method(){ 
System.out.println("Outer method run"); 
} 
public Innter getInnterInstance(){ 
return inner; 
} 
public static Outer getOuterInstance(){ 
return outer; 
} 
} 
class Test{ 
public static void main(String[] args){ 
//打印外部类的method方法 
Outer.getOuterInstance().method(); 
//打印内部类的method方法 
Outer.getOuterInstance().getInnterInstance().method(); 
} 
}

匿名内部类：

匿名内部类。就是内部类的简写格式。

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

必须有前提：内部类必须继承或者实现一个外部类或者接口。（因为内部类是用父类的名字创建对象）

匿名内部类：其实就是一个匿名子类对象。

匿名内部类格式：new 父类或者(or)接口(){子类成员}

通常的使用场景之一：

当函数参数是接口类型时，而且接口中的方法不超过三个。

可以用匿名内部类作为实际参数进行传递。

匿名内部类应用：

/*定义一个接口， 2个抽象方法（method two）*/ 
interface Inter  {   
void show1(); //默认是public abstract权限修饰 
void show2();   
}   
class Test  {   
public static void main(String[] args){ 
/* 
调用show方法show方法接口一个Inter对象，并将匿名内部类对象当成参数进行传递 
*/ 
show(new Inter()  {   
/* 
由于Inter父类的方法不超过三个所以使用匿名内部类进行子类实例化。复写父类的2个方法 
*/ 
public void show1(){ 
System.out.println("show1 run"); 
}   
public void show2(){ 
System.out.println("show2 run"); 
}   
});  
}   
public static void show(Inter in){   
/* 
调用Inter类的方法，子类实例化过一次，被子类进行了复写动作，所以打印的是子类实例化后的方法。 
*/ 
in.show1();  //打印show1 run 
in.show2();  //打印show2 run 
}   
}   
//内部类 匿名内部类注意之细节： 
abstract class Inner{ 
public abstract void method(); 
} 
class Test { 
//创建一个Test的内部类Innter对象。 
private Inner inner =/*this.*/new TestInner();//从这里可以看出来，创建内部类前面省略了一个this 
/* 
Inner内部类 method内部类方法 
但是我们学过匿名内部类，可以用匿名内部类的形式进行复写。 
new Inner(){ 
public void method(){ 
System.out.println("Inner Method Run"); 
} 
}代表是的Inner类的子类对象，并对父类的方法进行了复写。 
*/ 
class TestInner extends Inner { 
/* 
内部类的出来再一次打破了单继承的局限性.匿名内部类更加对代码进行了简化。 
*/ 
public void method(){ 
System.out.println("Inner Method Run"); 
} 
} 
/* 
由于主函数调用非静态方法，所以只能创建对象。 
*/ 
public static void main(String[] args) { 
new Test().method().method(); 
/*Object obj = new Object (){ 
public void show(){ 
System.out.println("Object Show Run"); 
} 
} 
创建Object的子类对象，但是Object类中的没有show方法，所以编译失败。多态看的是引用型变量对象中是否有对应的方法。 
*/ 
} 
/* 
返回内部类对象。 
*/ 
public Inner method(){ 
return inner; 
} 

} 
/*定义一个接口， 2个抽象方法（method two）*/ 
interface Inter  {   
void show1(); //默认是public abstract权限修饰 

void show2();   
}   
class Test  {   
public static void main(String[] args){ 
/* 
调用show方法show方法接口一个Inter对象，并将匿名内部类对象当成参数进行传递 
*/ 
show(new Inter()  {   
/* 
由于Inter父类的方法不超过三个所以使用匿名内部类进行子类实例化。复写父类的2个方法 
*/ 
public void show1(){ 
System.out.println("show1 run"); 
}   
public void show2(){ 
System.out.println("show2 run"); 
}   
});  
}   
public static void show(Inter in){   
/* 
调用Inter类的方法，子类实例化过一次，被子类进行了复写动作，所以打印的是子类实例化后的方法。 
*/ 
in.show1();  //打印show1 run 
in.show2();  //打印show2 run 
}   
}   
内部类 匿名内部类注意之细节： 
abstract class Inner{ 
public abstract void method(); 
} 
class Test { 
//创建一个Test的内部类Innter对象。 
private Inner inner =/*this.*/new TestInner();//从这里可以看出来，创建内部类前面省略了一个this 
/* 
Inner内部类 method内部类方法 
但是我们学过匿名内部类，可以用匿名内部类的形式进行复写。 
new Inner(){ 
public void method(){ 
System.out.println("Inner Method Run"); 
} 
}代表是的Inner类的子类对象，并对父类的方法进行了复写。 
*/ 
class TestInner extends Inner { 
/* 
内部类的出来再一次打破了单继承的局限性.匿名内部类更加对代码进行了简化。 
*/ 
public void method(){ 
System.out.println("Inner Method Run"); 
} 
} 
/* 
由于主函数调用非静态方法，所以只能创建对象。 
*/ 
public static void main(String[] args) { 
new Test().method().method(); 
/*Object obj = new Object (){ 
public void show(){ 
System.out.println("Object Show Run"); 
} 
} 
创建Object的子类对象，但是Object类中的没有show方法，所以编译失败。多态看的是引用型变量对象中是否有对应的方法。 
*/ 
} 
/* 
返回内部类对象。 
*/ 
public Inner method(){ 
return inner; 
} 
} 

Object类

Object：所有类的根类。 

Object：是不断抽取而来，具备着所有对象都具备的共性内容。

常用的共性内容:

equals方法：

指示其它某个对象是否与此对象“相等”。

equals和==的区别：

经常被简单的理解为equals方法用来比较两个对象中的数据是否相同，

而==比较运算符用来比较两个基本数据类型的数值是否相同或者二个对象的内存地址值是否相同。

这样的理解无可厚非，但还要透过简单看看本质，才会更清晰。

那equals方法还有什么用呢？

虽然每个对象都有自己的内存地址，但是每个对象也有自己的一些特有的特征。

比如学生对象有自己的姓名和年龄，希望根据姓名和年龄的相同来判断学生对象的数据内容是否相同。

这时使用Object类的equals就不能满足需求了，

就需要通过覆盖equals的方式，建立学生对象比较相同的具体内容。

public boolean equals(Object obj){

if(姓名和年龄相同)

return true;

return false;

}

Student s1 = new Student("黑马程序员",20);

Student s2 = new Student("黑马程序员",20);

System.out.println(s1==s2);

 /*结果是false，比较两个对象的地址值，因为都是new出现的实体，所以内存地址值也就不同。*/

System.out.println(s1.equals(s2));//结果是true，比较的是对象的数据中的具体内容。

所以，在用Java的类描述对象的时候，如果要判断该对象是否相同时，

通常都会覆盖equals方法，建立根据该对象特征进行比较相同的依据。

这也就是大家常听到的"equals是用来比较对象内容"的原因。

Java中很多对象都覆盖了equals方法，建立该对象特有的比较相同的方式。

比如String，Integer，Boolean等。

hashCode方法：

返回该对象的哈希码值。

根据对象的不同，可以覆盖父类的hashCode方法。

如Person类中

public int hashCode(){

return age;

}

内存地址值返回的是人对象的年龄。

getClass方法：

                           返回对象的运行时类。简单的说就是获取当前对象所属的字节码文件对象。

toString方法：

返回该对象的字符串表示。

Java默认的toString方法：

public String toString(){

                                            return getClass().getName() +"@" +Integer.toHexString(hashCode());

}

保留该功能，建立自己特有内容，覆盖该方法。

覆盖Person类中的toString方法：

public String toString(){

return"Person :"+age;

}