JAVA------面向对象：成员内部类和匿名内部类

1. 成员内部类：应用率不高

   - 类中套类，外面的称为外部类，里面的称为内部类

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

   - 内部类对象通常只在外部类中创建

   - 内部类中可以直接访问外部类的成员(包括私有的)，

     在内部类中有一个隐式的引用指向了创建它的外部类对象-------外部类名.this(API时会用)

   - 何时用：若一个类A只能被另一个类B使用，并且还想访问B中的成员，可以设计为成员内部类，访问方便

2. 匿名内部类：应用率高-------------------------------------简化代码的操作

   - 何时用：若想创建一个类(派生类)的对象，并且对象只被创建一次，可以设计为匿名内部类
   - 匿名内部类中不能修改外面局部变量的值，因为在此处该变量会默认为final的

补充：

1. 隐式的引用：

   - this：指代当前对象
   - super：指代当前对象的超类对象
   - 外部类名.this：指代当前对象的外部类对象

2. 小面试题：

   - 问：内部类有独立的.class吗？
   - 答：有

3. 做功能的套路：------------------------重点之重点

   - 先写行为/方法：
     - 若为某个对象所特有的行为，就将方法设计在特定的类中
     - 若为所有对象所共有的行为，就将方法设计在超类中
   - 窗口调用：
     - 若为定时发生的，则在定时器run中调用
     - 若为事件触发的，则在侦听器中调用

4. 调用方法的规则：

   - 方法有返回值，则必须声明变量来接收。方法没有返回值，则不需要声明变量接收。
   - 同一个类中的方法，可以直接方法名调用
   - 不同类中的方法：
     - 若为实例方法，则通过引用变量打点调用
     - 若为静态方法，则通过类名打点调用

package cn.tedu.submarine;
import jdk.nashorn.internal.runtime.UnwarrantedOptimismException;

import java.util.Arrays;
import java.util.Random;
import java.util.Timer;
import java.util.TimerTask;
import javax.swing.JPanel;
import javax.swing.JFrame;
import java.awt.Graphics;

public class World extends JPanel{
    public static final int WIDTH=641;//窗口宽
    public static final int HEIGHT=479;//窗口高

    private Battleship ship=new Battleship();
    private SeaObject[] submarines={};
    private Mine[] mines={};
    private Bomb[] bombs={};

    //生成潜艇
    private SeaObject nextSubmarine(){
        Random rand=new Random();
        int type=rand.nextInt(20);
        if(type<10){
            return new ObserveSubmarine();
        }else if(type<15){
            return new TorpedoSubmarine();
        }else{
            return new MineSubmarine();
        }
    }
    //海洋对象移动
    private void moveAction(){
        for(int i=0;i<submarines.length;i++){
            submarines[i].move();
        }
        for(int i=0;i<mines.length;i++){
            mines[i].move();
        }
        for(int i=0;i<bombs.length;i++){
            bombs[i].move();
        }
    }


    //控制水雷进场时间：
    private int mineEnterIndex=0;
    //水雷进场：
    private void  mineEnterAction(){
        mineEnterIndex++;
        if (mineEnterIndex%100==0){
            //
        }
    }


    //控制潜艇进场时间
    private int submarineEnterIndex=0;
    //潜艇进场：
    private void submarineEnterAction(){
        submarineEnterIndex++;
        if(submarineEnterIndex%40==0) {
            SeaObject obj = nextSubmarine();
            submarines = Arrays.copyOf(submarines, submarines.length + 1);
            submarines[submarines.length - 1] = obj;
        }
    }

   //程序执行：
    private void action(){
        Timer timer=new Timer();
        int interval=10;
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                submarineEnterAction();
                mineEnterAction();
                moveAction();



                repaint();
            }
        }, 10, 10);
    }


    //重写画方法：
    public void paint(Graphics g){
        //this.getImage().paintIcon(null,g,this.x,this.y);
        Images.sea.paintIcon(null,g,0,0);
        ship.paintImage(g);
        for (int i=0;i<submarines.length;i++){
            submarines[i].paintImage(g);
        }
        for (int i=0;i<mines.length;i++){
            mines[i].paintImage(g);
        }
        for (int i=0;i<bombs.length;i++){
            bombs[i].paintImage(g);
        }
    }
    public static void main(String[] args) {

        JFrame frame=new JFrame();
        World world=new World();
        world.setFocusable(true);
        frame.add(world);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(WIDTH+16,HEIGHT+39);
        frame.setLocationRelativeTo(null);
        frame.setResizable(false);
        frame.setVisible(true);//自动调用paint()方法
        world.action();
    }
}