面向对象第6 天

回顾     

     1.final:最终的、不能改变的；

            变量不能被改变，方法不能被重写，类不能被继承；

     2.static final：

              *必须声明同时初始化，由类名点访问，不能改变；

              *大写、多个单词-分隔；

              *编译器在编译时会将常量替换为具体的值；

              *数据永远不变，并且经常使用；

     3.抽象方法：

               abatrct修饰，只有方法的定义，没有具体的实现（连{}都没有）；

    4.抽象类：

              abstract修饰，包含抽象方法的类是抽象类，

              不能被实例化；

               抽象类是需要被继承的，派生类重写所有方法；

技能点：成员内部类、匿名内部类；

1.成员内部类

        *类中套类，外面的成为外部类，里面的称为内部类；

        *内部类只服务于外部类，对外不具备可见性；

        *内部类对象通常在外部类中创建；

        *内部类中可以直接访问外部类的成员；

            内部类中有一个隐式的引用指向了创建它的外部类对象----------外部类名.this;

        *何时用：若一个类A只被另一个类B使用，还想访问B中的成员，可设计为匿名内部类；

public class InnerClassDemo{
    public static void main(String[] args){
         Mama m=new Mama();
        // Cat c=new Cat();  //编译错误，内部类对外不具备可见性；
   }
}

class GG{//外部类；
    private int age;
    void show(){
        Baby b=new Baby();
}
class Cat{//成员内部类；
    void showName(){
     System.out.println(age);
     System.out.println(GG.this.age);
    // System.out.println(this.name);// 编译错误，this指代当前Baby对象；
        }
    }
}

2.匿名内部类

         *何时用：若想创建一个类的对象，并且对象只被创建一次，可以设计为匿名内部类；

         *匿名内部类中不能修改外面局部变量的值，在此处该变量会默认为final的;---API时会用；

public class InterDemo{

        public static void main(String[] args){

               Aoo o1=new Aoo(){};

             //1)创建了Aoo的一个派生类，但是没有名字；

             //2)为该派生类创建了对象o1

             //3)大括号中的为派生类的类体；

           int num=5;

           num=6;

            Boo o1=new Boo(){

                   void show(){

                            System.out.println("showshow");

                         // num=16;  //编译错误，此处会默认为final的；

             }

   };

o3.show;

             }

}

abstract class Boo{

         abstract void show();

}

 abstract class Aoo{}

补充：

     1.隐式的引用：

             *this:指代当前对象；

             *super:指代当前对象的超类对象；

             * 外部类名.this:  指代当前对象的外部类对象；

     2.小面试题：

             *内部类有独立的.class吗?

             *答：有；

     3.做功能的套路：

               *先写行为/方法：

                       * 若为某个对象所特有的，则将方法设计在特定的类中；

                       *若为所有对象共有的行为，将方法设计在超类中；

               *窗口调用：

                         *若为定时发生，则在定时器run中调用；

                         *若为事件触发，则在侦听器中调用；

     4.调用方法的规则：

              *方法有返回值，则必须接收。方法没有返回值，则直接调用即可；

              *同一个类中的方法，可以直接调用；

              *不同类中的方法：

                        *若为实例方法：通过引用变量打点；

                        *若为静态方法：通过类名打点调用；

      5.如何调错：

            *打桩：System.out.println(数据)；-----------不着急慢慢来，打得多了就有经验了

            *