初学Java第十天

笔记

1. 向上造型：

   - 超类型的引用指向派生类的对象
   - 能点出来什么，看引用的类型-----------这是规定，记住就行了

   ```java
   public class UploadDemo {
       public static void main(String[] args) {
           Aoo o1 = new Aoo();
           o1.a = 1;
           o1.show();
           //o1.b = 2;  //编译错误，超类不能访问派生类的
           //o2.test(); //编译错误
   
           Boo o2 = new Boo();
           o2.b = 1;
           o2.test();
           o2.a = 2;  //正确，派生类可以访问超类的
           o2.show(); //正确
   
           Aoo o3 = new Boo(); //向上造型
           o3.a = 1;
           o3.show();
           //o3.b = 2;  //编译错误，能点出来什么，看引用的类型
           //o3.test(); //编译错误
       }
   }
   
   class Aoo{
       int a;
       void show(){
       }
   }
   class Boo extends Aoo{
       int b;
       void test(){
       }
   }
   ```

2. 方法的重写(override/overriding)：重新写

   - 发生在父子类中，方法名相同，参数列表相同------派生类中重写了超类的方法
   - 重写方法被调用时，看对象的类型--------这是规定，记住就行了

   ```java
   class 餐馆{
       void 做餐(){ 做中餐 }   
   }
   //1)我还是想做中餐-------------不需要重写
   class Aoo extends 餐馆{
   }
   //2)我想改做西餐---------------需要重写
   class Aoo extends 餐馆{
       void 做餐(){ 做西餐 }
   }
   //3)我想在中餐之上加入西餐-------需要重写(先super中餐，再加入西餐)
   class Aoo extends 餐馆{
       void 做餐(){
           super.做餐(); + 做西餐
       }
   }
   ```

   - 重写需遵循"两同两小一大"原则：-----------一般都是一模一样的，了解即可

     - 两同：
       - 方法名相同
       - 参数列表相同
     - 两小：
       - 派生类方法的返回值类型小于或等于超类方法的
         - void和基本类型时，必须相等
         - 引用类型时，可以小于或等于
       - 派生类方法抛出的异常小于或等于超类方法的------------API时再说
     - 一大：
       - 派生类方法的访问权限大于或等于超类方法的-------------明天上午讲

     ```java
     //超类大，派生类小
     class Coo{
         void show(){}
         double test(){ return 0.0; }
         Student say(){ return null; }
         Person sayHi(){ return null; }
     }
     class Doo extends Coo{
         //int show(){ return 1; } //编译错误，void时必须相等
         //int test(){ return 0; } //编译错误，基本类型时必须相等
         //Person say(){ return null; } //编译错误，引用类型时必须小于或等于
         Student sayHi(){ return null; } //正确，Student小于Person
     }
     ```

3. 重写与重载的区别：-------------常见面试题

   - 重写(override)：发生在父子类中，方法名相同，参数列表相同
   - 重载(overload)：发生在同一类中，方法名相同，参数列表不同

## 精华笔记：

1. 向上造型：
   - 超类型的引用指向派生类的对象
   - 能点出来什么，看引用的类型-----------这是规定，记住就行了
2. 方法的重写(override/overriding)：重新写
   - 发生在父子类中，方法名相同，参数列表相同------派生类中重写了超类的方法
   - 重写方法被调用时，看对象的类型----------------------这是规定，记住就行了
   - 重写需遵循"两同两小一大"原则：-----------一般都是一模一样的，了解即可
     - 两同：
       - 方法名相同
       - 参数列表相同
     - 两小：
       - 派生类方法的返回值类型小于或等于超类方法的
         - void和基本类型时，必须相等
         - 引用类型时，可以小于或等于
       - 派生类方法抛出的异常小于或等于超类方法的------------API时再说
     - 一大：
       - 派生类方法的访问权限大于或等于超类方法的-------------
3. 重写与重载的区别：-------------常见面试题
   - 重写(override)：发生在父子类中，方法名相同，参数列表相同
   - 重载(overload)：发生在同一类中，方法名相同，参数列表不同

## 补充：

1. 继承要符合is(是)的关系

2. 何时向上造型：

   - 当多种角色所干的事几乎一样时，可以将它们统一造型到一个数组中，复用

     eg: 学生/老师/医生都在输出名字并问好，就将它们统一造型到Person数组中，一个for

     ​      即可，实现代码的复用

     eg:所有潜艇能干的事几乎都一样，所以将三种潜艇统一造型到SeaObject数组中

 

1. 将侦察艇数组、鱼雷艇数组、水雷艇数组统一组合为SeaObject数组，给数组填充数据，遍历数组输出属性并调用move()方法

```java
   package day04;
   //整个游戏世界
   public class World {
       public static void main(String[] args) {
           SeaObject[] submarines = new SeaObject[5]; //潜艇(侦察潜艇、鱼雷潜艇、水雷潜艇)
           submarines[0] = new ObserveSubmarine();
           submarines[1] = new ObserveSubmarine();
           submarines[2] = new TorpedoSubmarine();
           submarines[3] = new TorpedoSubmarine();
           submarines[4] = new MineSubmarine();
           for(int i=0;i
               SeaObject s = submarines[i];
               System.out.println(s.x+","+s.y);
               s.move();
           }
   
           Battleship s = new Battleship();
   
           Mine[] mines = new Mine[2];
           mines[0] = new Mine(100,200);
           mines[1] = new Mine(200,400);
           for(int i=0;i
               Mine m = mines[i];
               System.out.println(m[i].x+","+m[i].y);
               m[i].move();
           }
   
           Bomb[] bombs = new Bomb[2];
           bombs[0] = new Bomb(100,200);
           bombs[1] = new Bomb(200,400);
           for(int i=0;i
               Bomb b = bombs[i];
               System.out.println(b[i].x+","+b[i].y);
               b[i].move();
           }
       }
   }
   

2. 在6个类中重写move()移动方法，实现对象的具体移动，并测试

   参考代码：

   ```java
   package day04;
   //战舰
   public class Battleship extends SeaObject {
       int life;
       Battleship(){
           super(66,26,270,124,20);
           life = 5;
       }
       void move(){
           //暂时搁置
       }
   }
   
   package day04;
   //侦察潜艇
   public class ObserveSubmarine extends SeaObject {
       ObserveSubmarine(){
           super(63,19);
       }
       void move(){
           x+=speed;
       }
   }
   
   package day04;
   //鱼雷潜艇
   public class TorpedoSubmarine extends SeaObject {
       TorpedoSubmarine(){
           super(64,20);
       }
       void move(){
           x+=speed;
       }
   }
   
   package day04;
   //水雷潜艇
   public class MineSubmarine extends SeaObject {
       MineSubmarine(){
           super(63,19);
       }
       void move(){
           x+=speed;
       }
   }
   
   package day04;
   //水雷
   public class Mine extends SeaObject {
       Mine(int x,int y){
           super(11,11,x,y,1);
       }
       void move(){
           y-=speed;
       }
   }
   
   package day04;
   //深水炸d
   public class Bomb extends SeaObject {
       Bomb(int x,int y){
           super(9,12,x,y,3);
       }
       void move(){
           y+=speed;
       }
   }
   
   package day04;
   /** 整个游戏窗口 */
   public class World {
       public static void main(String[] args) {
           SeaObject[] submarines = new SeaObject[5]; //潜艇数组
           submarines[0] = new ObserveSubmarine(); //向上造型
           submarines[1] = new ObserveSubmarine();
           submarines[2] = new TorpedoSubmarine();
           submarines[3] = new TorpedoSubmarine();
           submarines[4] = new MineSubmarine();
           for(int i=0;i                System.out.println("第"+(i+1)+"个潜艇:");
               SeaObject s = submarines[i]; //获取每一个潜艇
               System.out.println("初始的坐标:"+s.x+","+s.y);
               s.move(); //移动
               System.out.println("移动后坐标:"+s.x+","+s.y); //移动后坐标
           }
   
           Mine[] mines = new Mine[4];
           mines[0] = new Mine(100,200);
           mines[1] = new Mine(110,120);
           mines[2] = new Mine(130,140);
           mines[3] = new Mine(140,150);
           for(int i=0;i                System.out.println("第"+(i+1)+"个水雷:");
               Mine m = mines[i];  //获取每一个水雷
               System.out.println("初始的坐标:"+m.x+","+m.y);
               m.move();
               System.out.println("移动后坐标:"+m.x+","+m.y);
           }
   

  参考代码：

   ```java
   package day04;
   import javax.swing.JFrame;
   import javax.swing.JPanel;
   //整个游戏世界
   public class World extends JPanel {
       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(641+16, 479+39);
           frame.setLocationRelativeTo(null);
           frame.setVisible(true);
       }
   }

           Bomb[] bombs = new Bomb[2];
           bombs[0] = new Bomb(100,200);
           bombs[1] = new Bomb(200,185);
           for(int i=0;i
               System.out.println("第"+(i+1)+"个深水炸d:");
               Bomb b = bombs[i];
               System.out.println("初始的坐标:"+b.x+","+b.y);
               b.move();
               System.out.println("移动后坐标:"+b.x+","+b.y);
           }
       }
   }

3. 画窗口

  参考代码：

   ```java
   package day04;
   import javax.swing.JFrame;
   import javax.swing.JPanel;
   //整个游戏世界
   public class World extends JPanel {
       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(641+16, 479+39);
           frame.setLocationRelativeTo(null);
           frame.setVisible(true);
       }
   }