黑马程序员---了解开发工具及内部类

来源：互联网发布：mac 下载不在dock 编辑：程序博客网时间：2024/06/05 15:45

---------------------- 黑马程序员 Android培训、期待与您交流！ ---------------------

1：包

   (1)其实就是文件夹。
   (2)作业：把同名称的类放到不同的文件夹下使用。
   (3)格式：
       package xxx.yyy.zzz;
   (4)带包的类的编译和运行：
       A:手动式
           a:javac编译当前类文件。
           b:手动建立包对应的文件夹。
           c:把a的class文件放到b的最终文件夹下。
           d:通过java命令执行。注意了：需要带包名称的执行。
               java cn.itcast.HelloWorld
       B:自动式
           a:javac编译的时候带上-d即可
               javac -d . HelloWorld.java
           b:通过java命令执行。注意了：需要带包名称的执行。
               java cn.itcast.HelloWorld


2：导包
   (1)一般来说，用一个类，需要用该类的全路径名称。
       如果多个地方使用，就比较麻烦，所以java提供了导包操作。
   (2)格式：
       import 包名1.包名2...类名;

       //下面这种属于把指定包下的类都导入。这种用法不推荐。我们应该用谁导谁。
       import 包名1.包名2...*;
   (3)package，import，class的顺序
       package -- import -- class

3：四种权限修饰符
   (1)案例：
       cn.itcast
           Fu
           Zi
           Demo
       com.liuyi
           Zi
           Demo
   (2)结论:
                                  本类   同包(无关类或者子类)   不同包(子类)   不同包(无关类)
   private   Y
   默认(什么都没有)    Y      Y
   protected        Y      Y              Y
   public                       Y    Y              Y                     Y

   推荐：
       成员变量   private
       构造方法   public
       成员方法   public

4：不同修饰符修饰的内容
          类   成员变量   成员方法   构造方法
   private           Y         Y          Y
   默认      Y      Y       Y          Y
   protected   Y         Y      Y
   public      Y        Y               Y                Y
   abstract    Y           Y
   static          Y          Y
   final       Y Y          Y


   类：public
   成员变量：private
   构造方法：public
   成员方法：public

   注意，常见规则如下：
       以后，所有的类都用public修饰。并且，在一个java文件中，只写一个类。

       以后，所有的成员变量用private修饰。

       以后，所有的成员方法用public修饰。
           如果是抽象类或者接口：
               public abstract + ...

       以后，所有的构造方法用public修饰。
           如果类是工具类或者单例类：
               构造用private修饰

5：内部类
   (1)把类定义在其他类的内部，就被称为内部类。
   (2)访问特点：
       A:内部类可以直接访问外部类成员，包括私有
       B:外部类要想访问内部类成员，必须创建对象。
   (3)内部类的分类：
       A:成员内部类
           a:private 访问的安全性
           b:static 访问的方便
       B:局部内部类
           a:带名字的(类)
           b:不带名字的(对象)

           局部内部类访问局部变量必须加final修饰。
           延迟生命周期。
   (4)匿名内部类
       A:是定义在局部位置的没有名字的内部类。
       B:前提
           存在一个类，抽象类，或者接口。
       C:格式
           new 类或者接口名()
           {
               重写方法;
           }

           本质理解：其实这是一个继承类或者实现接口的匿名的子类对象。
       D:使用
           当你看到方法的形式参数是接口或者抽象类的时候。
           用匿名内部类改进。

经典习题总结:

第一题：
   class Fu {
       public void show() {
           System.out.println("show fu");
       }
   }

   //在这里如何写。
   class Zi extends Fu {
       public void show() {
           System.out.println("show zi");
       }
   }

   class FuDemo {
       public void testFu(Fu f) {
           f.show();
       }
   }

   class FuTest {
       public static void main(String[] args) {
           FuDemo fd = new FuDemo();
           //补齐代码,在控制台输出"show zi"
           Fu f = new Zi();
           fd.testFu(f);
       }
   }

   第二题：
   abstract class Fu {
       public abstract void show();
   }

   //在这里如何写。
   class Zi extends Fu {
       public void show() {
           System.out.println("show");
       }
   }

   class FuDemo {
       //如果你看到一个方法的形式参数是一个抽象类名，那么，这里将来接收的肯定是一个子类对象。
       public void testFu(Fu f) {
           f.show();
       }
   }

   class FuTest {
       public static void main(String[] args) {
           FuDemo fd = new FuDemo();
           //补齐代码,在控制台输出"show"
           Fu f = new Zi();
           fd.testFu(f);
       }
   }

   第三题：
   interface Fu {
       public abstract void show();
   }

   //在这里如何写。
   class Zi implements Fu {
       public void show() {
           System.out.println("show zi");
       }
   }

   class FuDemo {
       //如果你看到一个方法的形式参数是一个接口名，那么，这里将来接收的肯定是一个子类对象。
       public void testFu(Fu f) {
           f.show();
       }
   }

   class FuTest {
       public static void main(String[] args) {
           FuDemo fd = new FuDemo();
           //补齐代码,在控制台输出"show zi"
           Fu f = new Zi();
           fd.testFu(f);
       }
   }

总结：
   引用类型：类，接口，数组。

   形式参数是引用类型的时候：
       如果是一个具体类类名，要的是该类的或者其子类对象。
       如果是一个抽象类名，要的是该类的子类对象。
       如果是一个接口名，要的是该接口的实现类的对象。

   返回值是引用类型的时候：
       如果是一个具体类类名，返回是该类或者其子类对象。
       如果是一个抽象类名，返回是该类的子类对象。
       如果是一个接口名，返回是该接口的实现类的对象。

   abstract class Fu {

   }

   class Zi extends Fu {

   }

   class FuDemo {
       public Fu getFu() {
           //Fu f = new Fu();
           //return f;
           Fu f = new Zi();
           return f;
       }
   }

   结论：
       父亲的地方，可以是父亲或者儿子。
       儿子的地方，只能是儿子。

       子类对象可以当父类对象用，父类对象不能当子类对象用。

匿名内部类的例题 :

    第一种：

           interface Inter {
               public abstract void show();
           }

           class InterDemo {
               public void method(Inter i) {
                   i.show();
               }
           }

           class InterTest {
               public static void main(String[] args) {
                   InterDemo id = new InterDemo();
                   id.method(new Inter(){
                       public void show() {
                           System.out.println("HelloWorld");
                       }
                   });
               }
           }

   第二种：

           interface Inter {
               void show();
           }

           class Outer {
               //补齐代码
               public static Inter method() {
                   return new Inter(){
                       public void show() {
                           System.out.println("show");
                       }
                   };
               }
           }

           class OuterDemo {
               public static void main(String[] args) {
                   Outer.method().show();
               }

}

---------------------- 黑马程序员 Android培训、期待与您交流！ ---------------------

0 0