Java面向对象04

1.成员内部类： 

• 类中套类，外面的称为外部类，里面的称为内部类
• 内部类通常只服务于外部类，对外不具备可见性
• 内部类对象只能在外部类中创建
• 内部类中可以直接访问外部类的成员(包括私有的)，在内部类中有个隐式的引用指向了创建它的外部类对象------外部类名.this

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

class Mama{ //外部类
    private String name;
    Baby b = new Baby(); //内部类对象通常在外部类中创建
    class Baby{ //内部类
        void show(){
            System.out.println(name);
            System.out.println(Mama.this.name); //Mama.this指代它的外部类对象
        }
    }
}

 内部成员类是普通方法：(静态不能调非静态)

内部成员类是静态方法： 

 

 

2. 匿名内部类：

• 若想创建一个类(派生类)的对象，并且对象只创建一个，此时该类不必命名，称为匿名内部类
• 匿名内部类中不能修改外面变量的值，因为在此处该变量默认为final的

public class AnonInnerClassDemo {
    public static void main(String[] args) {
        //1)创建了Aoo的一个派生类，但是没有名字
        //2)为该派生类创建了一个对象，名为o1
        //3)大括号中的为派生类的类体
        Aoo o1 = new Aoo(){
        };

        //1)创建了Aoo的一个派生类，但是没有名字
        //2)为该派生类创建了一个对象，名为o2
        //3)大括号中的为派生类的类体
        Aoo o2 = new Aoo(){
        };


        int num = 5;
        num = 55;
        //1)创建了Boo的一个派生类，但是没有名字
        //2)为该派生类创建了一个对象，名为o3
        //3)大括号中的为派生类的类体
        Boo o3 = new Boo(){
            void show(){
                System.out.println("showshow");
                //num = 66; //编译错误，匿名内部类中不能修饰外面变量的值，因为在此处默认为final的
            }
        };
        o3.show();
    }
}

abstract class Boo{
    abstract void show();
}

abstract class Aoo{
}

public abstract class Aoo(){
  public abstract void move();
}

public class Boo extends Aoo(){
  public void move(){
    System.out.println("移动");
  }
}

Boo b = new Boo();
b.move();


//等同于如下匿名内部类：
public class Coo(){

   Aoo b = new Aoo(){
     public void move(){
    System.out.println("移动");
    }
   b.move();
    //其中b指的是系统自动给的子类的对象，{ }指的是子类的方法体，所以直接b.move() 
  }

}

补充：

1. 隐式对象：

• this：当前对象
• super：当前对象的超类对象
• 外部类名.this：当前对象的外部类对象

 

 

2. 

• 外部类名.this：指代当前对象的外部类对象
• 匿名内部类不能修改外面变量的值，因为在此处默认为final的

3. 

• 问：内部类有独立的.class字节码文件吗？

  答：有

4. 

• 先写行为/方法：

  • 若为某对象所特有的行为，就将方法设计在特定的类中
  • 若为所有对象所共有的行为，就将方法设计在超类中

• 窗口调用：

  • 若为定时发生的，就在定时器中调用
  • 若为事件触发的，就在侦听器中调用

5. 调错方式：

• 打桩：System.out.println(数据);

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

 1.接口：

• 是一种引用数据类型
• 由interface定义
• 只能包含常量和抽象方法
• 接口不能被实例化(new对象)
• 接口是需要被实现/继承的，实现类/派生类：
  ----必须重写所有抽象方法
• 一个类可以实现多个接口，用逗号分隔，若又继承又实现时，应先继承后实现
• 接口可以继承接口

//接口的演示
public class InterfaceDemo {
    public static void main(String[] args) {
        //Inter5 o1 = new Inter5(); //编译错误，接口不能被实例化
        Inter5 o2 = new Doo(); //向上造型(可以造型为它所实现的接口)
        Inter4 o3 = new Doo(); //向上造型
    }
}

//演示接口继承接口
interface Inter4{
    void show();
}
interface Inter5 extends Inter4{
    void test();
}
class Doo implements Inter5{
    public void test(){}
    public void show(){}
}

//演示接口多实现
interface Inter2{
    void show();
}
interface Inter3{
    void test();
}
abstract class Boo{
    abstract void say();
}
class Coo extends Boo implements Inter2,Inter3{
    public void show(){}
    public void test(){}
    public void say(){}
}

//演示接口的实现
interface Inter1{
    void show(); //访问权限默认是public
    void test();
}
class Aoo implements Inter1{
    public void show(){} //重写接口中的抽象方法，访问权限必须是public
    public void test(){}
}

//演示接口的语法
interface Inter{
    public static final int NUM = 5; //接口中成员的访问权限只能是public的
    public abstract void show();
    int COUNT = 6; //默认public static final
    void say(); //默认public abstract
    //int number; //编译错误，常量必须声明同时初始化
    //void test(){} //编译错误，抽象方法不能有方法体
}

 补充：

1.接口中的常亮默认加public static final ，方法默认加public abstract。接口中成员修饰权限默认为public。

 

 2.重写接口中的抽象方法，修饰权限必须是public。

 3.    o2可以调用show()方法和test()方法，而03只能调用show()方法。

 

4. 关系：

• 类和类---------------------继承extends
• 接口和接口---------------继承extends
• 类和接口------------------实现implements

5. 设计规则：

将所有派生类所共有的属性和行为，抽到超类中---------------抽共性
若对象的行为都一样，设计为普通方法
若对象的行为不一样，设计为抽象方法
将部分派生类所共有的属性和行为，抽到接口中
接口是对继承的单根性的扩展---------------------------实现多继承

6.接口的意义：

• 实现多继承
• 制定了一套标准、规则

7. 如何调错：

1.快速定位错误方法:
  ----将方法调用的代码全都注释，然后一个一个放开，
  ----放开哪个方法出错了，就是那个方法的问题
2.打桩:
  ----System.out.println(数据);