黑马程序员_Java基础[17]_Object、内部类

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

【【Object】】类

/*

 *是所有类直接或者间接的父类       （超类    （最上层的类。
 *该类中定义的肯定是所有对象都具备的功能
 *        （所有对象都具备比较功能。
 *
 *Object类中已经提供了对对象是否相同的比较方法
 *
 *如果自定义类中也有比较相同功能，没有必要自己再定义
 *只要沿袭父类中的功能，建立自己特有的比较内容即可，这就是覆盖/复写。
 *
 *【应用技能】
 *1、向下转型，
 *2、instanceof 类型比较关键字
 *3、方法的复写/覆盖
 *4、多态
 *5、equals
 *6、toString（）和hashCode() 哈希值
 */
class Demo_a {   //extend Object {
    public int num;
    Demo_a(int num){
        this.num=num;
    }

    public boolean equals(Object obj){//Object obj=new Dem();  //复写    方法一模一样
        /*针对传入不同类型比较时，必然是false
         */
        if(!(obj instanceof Demo)){//类型比较 ，instanceof关键字。
            return false;    //不是同一个类型直接返回：
        }
        Demo_a  de=(Demo_a )obj;
        return this.num==de.num;
        /*
         *个人总结：在多态中，可以通过向下转换/强制转换的方式，使父类拥有子类的成员变量和方法。
         *就比较而言，想比较其他的，而这些功能父类已经定义了，子类只需要覆盖就可以，
         *        在这里只需要对传入的类型进行判断，然后进行向下转换即可完成功能。
         */
    }
    //public boolean equals(Demo d ){ //重载 参数列表不同
    //}
}
class Person_a{
    //建立一个人的类，也可以传入复写的比较方法中比较，只不过不同类型，必然是false；
}


public class Demo_Object {

    public static void main(String []args){
        //1 【equals】 任何对象都具备比较的功能。
        /*
        Demo d1=new Demo();
        Demo d2=new Demo();
        Demo d3=d1;
        System.out.println(d1.equals(d3));
        System.out.println(d1==d2);
        System.out.println(d1==d3);
        */
        /*
         * d1d2d3都指向一个地址，进行比较的时候，equals比较的是对象的值
         * 而==是比较的是地址
         */
        Demo_a d1=new Demo_a(4);
        Demo_a d2=new Demo_a(6);
        System.out.println(d1.equals(d2));
        //[toString]
        System.out.println(d1.toString());//打印的是该对象的哈希值。
        
    }
}
/*API里面：
 * boolean  |||||||         equals(Object obj)
 */

-----------------------------------------------------------------------------------------------------------------

【内部类】

 * 【内部类】
 *1、将一个类定义在另外一个类里面，对立面那个类就称为内部类（内置类，嵌套类）
 *2、访问特点：
 *    2.1、内部类可以直接访问外部类中的成员、私有成员
 *        之所以可以直接访问外部类中的成员，是因为内部类中持有一个外部类的引用，格式：   外部类名.this    具体看【a】
 *    2.2、外部类要访问内部类中的成员必须要建立内部类对象。
 *内部类是属于外部类的成员变量，是可以私有化的
 *
 *【1，内部类在main方法中格式，2内部类为什么可以直接访问外部类】
 *访问格式：
 *1、当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中直接建立内部类对象。
 *    格式：外部名.内部类名   变量名=new 外部类对象（）.new 内部类对象（）；
 *          Outer.Inner in=new Outer().new Inner();
 *
 *2、当内部类在成员位置上，就可以被成员修饰符所修饰。
 *    比如，private 将内部类在外部类中进行封装
 *         static ：内部类就具备了static的特性；
 *          当内部类被static修饰后，只能访问外部类中的static成员，出现了局限性。
 *
 *          在外部类中，如何直接访问内部类的非静态成员呢？
 *         new Outer.Inner().Function（）;
 *
 *          在外部类中，如何直接访问内部类的静态成员呢？
 *         new Outer.Inner.Function2（）;
 *注意：当内部类中定义了静态成员，该内部类必须是static的。
 *        当外部类中的静态方法访问内部类时，内部类也必须是静态的。【b】
 *【b】
 *在定义一个内部类：
 *
 *当描述事物时，事物的内部还有事物，该事物用内部类来描述，
 *因为内部事物在使用外部事物的内容。
 *
 *包含关系的时候就使用内部类。
 *【c】
 *内部类可以写在外部类的任意位置；【成员】或者【局部】。
 *【c】中属于局部内部类，但是访问规则没有改变，
 *        该类不能在被static修饰，因为static只修饰成员变量不能修饰局部成员
 *内部类定义在局部时
 *1,不可以被成员修饰符修饰
 *2,可以直接访问外部类中的成员变量，因为还持有外部类中的引用
 *    但是不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。
 *静态内部类出现的并不多
 */
class Outer{
    int x=3;
    //class Inner{  //内部类
    static class Inner{  //静态内部类
        int x=4;
        void Funtion(){
            int x=5;
            //内部类使用外部类成员和方法，可以直接调用
            System.out.println("内部类成员变量："+this.x);
            System.out.println("内部类局部变量："+x);
            //当内部类定义为静态内部类的时候，非静态的变量就不能访问了
            //System.out.println("外部类成员变量："+Outer.this.x);
            //注意看上面的结果，有3个x成员的值得【a】
        }
        static void funtion2(){
             System.out.println("funtion2");
         }
    }
    void method(){
        System.out.println("show   "+x);
        //外部类使用内部类成员和功能 必须创建内部类对象
        Inner in=new Inner();
        in.Funtion();
    }

    
//【b】又一个内部类：
    class Inner2{
        void show(){
             System.out.println("inner222");
            }
        }
    public static void method2(){
        Inner.funtion2();
        //new Inner2().show();
        /*发现，该静态方法调用静态内部类可以编译
         * 而调用非静态内部类编译出错。
         *
         */
    }
    //【c】
    //void method3(int a){  【mm】对应下列【mm】
    void method3(final int a){
        int x=3;
        final int y=4;
        class Inner3{
            void function3(){
                //System.out.println(x);  //不能访问该类所在的局部的变量
                System.out.println(y);    //而只能访问局部中final修饰的变量
                System.out.println(a);    //传入int a是编译错误，传入final 修饰的才可以通过【mm】
                System.out.println("该内部类属于局部内部类，但是访问规则没有改变。" +
                        "该类不能在被static修饰因为static只修饰成员变量不能修饰局部成员");
            }
        }
        new Inner3().function3();
    }

}




public class Demo_Neibulei {

    
    public static void main(String[] args) {
        
        //Outer ou=new Outer();
        //ou.method();
        //面试时候用：内部类想要在main方法中创建对象格式：
        //Outer.Inner in=new Outer().new Inner();
        //in.Funtion();
        
        //使用很少，面试可能出现。
         // 在外部类中，如何直接访问静态内部类非静态成员呢？
        new Outer.Inner().Funtion();
         // 在外部类中，如何直接访问静态内部类静态成员呢？
        Outer.Inner.funtion2();
    }

}

---------- android培训、 java培训、期待与您交流！----------
黑马官网： http://edu.csdn.net/heima