初学Java第十一天

笔记

1. package和import：

   - package：声明包
     - 作用：避免类的命名冲突
     - 同包中的类不能同名，不同包中的类可以同名
     - 类的全称：包名.类名，包名常常有层次结构
     - 建议：包名所有字母都小写
   - import：导入类
     - 同包中的类可以直接访问的，不同包中的类不能直接访问，若想访问：
       - 先import导入类，再使用类----------建议
       - 类的全称------------------------------------太繁琐，不建议

2. 访问控制修饰符：---------------------保护数据的安全

   - public：公开的，任何类

   - private：私有的，本类

   - protected：受保护的，本类、派生类、同包类

   - 默认的：什么也不写，本类、同包类---------------------java不建议

     > 说明：
     >
     > 1. 类的访问权限只能是public或默认的
     > 2. 类中成员的访问权限如上4种都可以
     > 3. 访问权限由大到小：public>protected>默认的>private

   ```java
   package ooday05;
   //访问控制修饰符的演示
   public class Aoo {
       public int a;    //任何类
       protected int b; //本类、派生类、同包类
       int c;           //本类、同包类
       private int d;   //本类
   
       void show(){
           a = 1;
           b = 2;
           c = 3;
           d = 4;
       }
   }
   
   class Boo{ //--------------演示private
       void show(){
           Aoo o = new Aoo();
           o.a = 1;
           o.b = 2;
           o.c = 3;
           //o.d = 4; //编译错误
       }
   }
   
   package ooday05_vis;
   import ooday05.Aoo;
   public class Coo { //--------演示同包的
       void show(){
           Aoo o = new Aoo();
           o.a = 1;
           //o.b = 2; //编译错误
           //o.c = 3; //编译错误
           //o.d = 4; //编译错误
       }
   }
   
   class Doo extends Aoo{ //跨包继承-----演示protected
       void show(){
           a = 1;
           b = 2;
           //c = 3; //编译错误
           //d = 4; //编译错误
       }
   }
   ```

   

3. final：最终的、不可改变的-------------单独应用率低，了解即可

   - 修饰变量：变量不能被改变
   - 修饰方法：方法不能被重写
   - 修饰类：类不能被继承 

   ```java
   //演示final修饰变量
   class Eoo{
       final int num = 5;
       void show(){
           //num = 8; //编译错误，final的变量不能被改变
       }
   }
   
   //演示final修饰方法
   class Foo{
       final void show(){}
       void test(){}
   }
   class Goo extends Foo{
       //void show(){} //编译错误，final的方法不能被重写
       void test(){}
   }
   
   //演示final修饰类
   final class Hoo{}
   //class Ioo extends Hoo{} //编译错误，final的类不能被继承
   class Joo{}
   final class Koo extends Joo{} //不能当老爸，但能当儿子
   ```

   

4. static：静态的

   - 静态变量：

     - 由static修饰
     - 属于类，存储在方法区中，只有一份
     - 常常通过类名点来访问
     - 何时用：所有对象所共享的数据(图片、音频、视频等)

     ```java
     public class StaticDemo {
         public static void main(String[] args) {
             Loo o1 = new Loo();
             o1.show();
             Loo o2 = new Loo();
             o2.show();
             Loo o3 = new Loo();
             o3.show();
             System.out.println(Loo.b); //常常通过类名点来访问
         }
     }
     //演示静态变量
     class Loo{
         int a; //实例变量
         static int b; //静态变量
         Loo(){
             a++;
             b++;
         }
         void show(){
             System.out.println("a="+a+"，b="+b);
         }
     }
     ```

   - 静态方法：

     - 由static修饰
     - 属于类，存储在方法区中，只有一份
     - 常常通过类名点来访问
     - 静态方法中没有隐式this传递，所以不能直接访问实例成员
     - 何时用：方法的操作与对象无关(不需要访问对象的数据)

     ```java
     public class StaticDemo {
         public static void main(String[] args) {
             int a = Noo.plus(5,6); //常常通过类名点来访问
         }
     }
     //演示静态方法
     class Moo{
         int a; //实例变量(通过对象来访问)
         static int b; //静态变量(通过类名来访问)
     
         void show(){ //有隐式this
             System.out.println(this.a);
             System.out.println(Moo.b);
         }
         static void test(){ //没有隐式this
             //静态方法中没有隐式this传递，没有this就意味着没有对象，
             //而实例成员a是必须通过对象来访问的，所以如下代码发生编译错误
             //System.out.println(a); //编译错误
             System.out.println(Moo.b);
         }
     }
     //演示静态方法的使用场景
     class Noo{
         int a; //实例变量(属于对象，描述对象的属性)
     
         //在show()中访问的对象的属性a，意味着与对象有关，所以不能设计为静态方法
         void show(){
             System.out.println(a);
         }
         //在plus()中没有访问对象的属性，意味着与对象无关，所以可以设计为静态方法
         static int plus(int num1,int num2){
             int num = num1+num2;
             return num;
         }
     }
     ```

   - 静态块：

     - 由static修饰
     - 属于类，在类被加载时自动执行，一个类只被加载一次，所以静态块只执行一次
     - 何时用：初始化/加载静态资源(图片、音频、视频等)

     ```java
     public class StaticDemo {
         public static void main(String[] args) {
             Poo o4 = new Poo();
             Poo o5 = new Poo();
             Poo o6 = new Poo();
         }
     }
     //演示静态块
     class Poo{
         static{
             System.out.println("静态块");
         }
         Poo(){
             System.out.println("构造方法");
         }
     }
     ```

     

## 精华笔记：

1. package和import：

   - package：声明包
     - 作用：避免类的命名冲突
     - 同包中的类不能同名，不同包中的类可以同名
     - 类的全称：包名.类名，包名常常有层次结构
     - 建议：包名所有字母都小写
   - import：导入类
     - 同包中的类可以直接访问的，不同包中的类不能直接访问，若想访问：
       - 先import导入类，再使用类----------建议
       - 类的全称------------------------------------太繁琐，不建议

2. 访问控制修饰符：---------------------保护数据的安全

   - public：公开的，任何类

   - private：私有的，本类

   - protected：受保护的，本类、派生类、同包类

   - 默认的：什么也不写，本类、同包类---------------------java不建议

     > 说明：
     >
     > 1. 类的访问权限只能是public或默认的
     > 2. 类中成员的访问权限如上4种都可以
     > 3. 访问权限由大到小：public>protected>默认的>private

3. final：最终的、不可改变的-------------单独应用率低，了解即可

   - 修饰变量：变量不能被改变
   - 修饰方法：方法不能被重写
   - 修饰类：类不能被继承 

4. static：静态的

   - 静态变量：
     - 由static修饰
     - 属于类，存储在方法区中，只有一份
     - 常常通过类名点来访问
     - 何时用：所有对象所共享的数据(图片、音频、视频等)
   - 静态方法：
     - 由static修饰
     - 属于类，存储在方法区中，只有一份
     - 常常通过类名点来访问
     - 静态方法中没有隐式this传递，所以不能直接访问实例成员
     - 何时用：方法的操作与对象无关(不需要访问对象的数据)
   - 静态块：
     - 由static修饰
     - 属于类，在类被加载时自动执行，一个类只被加载一次，所以静态块只执行一次
     - 何时用：初始化/加载静态资源(图片、音频、视频等)

## 补充：

1. 访问权限常规使用规则：

   - 实例变量一般都private
   - 方法绝大部分情况都是public的，但是若某方法只是我自己用，也是可以private的
   - 静态的一般都是public

2. 成员变量分两种：

   - 实例变量：没有static修饰，属于对象的，存储在堆中，有几个对象就有几份

     ​                   通过引用打点来访问

   - 静态变量：由static修饰，属于类的，存储在方法区中，只有一份

     ​                   通过类名打点来访问

3. 内存管理：由JVM管理

   - 堆：new出来的对象(包括实例变量)
   - 栈：局部变量(包括方法的参数)
   - 方法区：.class字节码文件(包括静态变量、所有方法)

4. 给成员变量赋值规则：

   - 静态变量，一般在静态块中初始化
   - 实例变量，一般在构造方法中初始化

作业

1. 给所有类中的成员添加访问控制修饰符

eight;
       protected int x;
       protected int y;
       protected int speed;
       public SeaObject(int width,int height){
           this.width = width;
           this.height = height;
           x = -width;
           Random rand = new Random();
           y = rand.nextInt(479-height-150+1)+150;
           speed = rand.nextInt(3)+1;
       }
       public SeaObject(int width,int height,int x,int y,int speed){
           this.width = width;
           this.height = height;
           this.x = x;
           this.y = y;
           this.speed = speed;
       }
   
       public void move(){
           System.out.println("海洋对象移动");
       }
   }
   
   package day05;
   //战舰
   public class Battleship extends SeaObject {
       private int life;
       public Battleship(){
           super(66,26,270,124,20);
           life = 5;
       }
       public void move(){
           //暂时搁置
       }
   }
   
   package day05;
   //侦察潜艇
   public class ObserveSubmarine extends SeaObject {
       public ObserveSubmarine(){
           super(63,19);
       }
       public void move(){
           x+=speed;
       }
   }
   
   package day05;
   //鱼雷潜艇
   public class TorpedoSubmarine extends SeaObject {
       public TorpedoSubmarine(){
           super(64,20);
       }
       public void move(){
           x+=speed;
       }
   }
   
   package day05;
   //水雷潜艇
   public class MineSubmarine extends SeaObject {
       public MineSubmarine(){
           super(63,19);
       }
       public void move(){
           x+=speed;
       }
   }
   
   package day05;
   //水雷
   public class Mine extends SeaObject {
       public Mine(int x,int y){
           super(11,11,x,y,1);
       }
       public void move(){
           y-=speed;
       }
   }
   
   package day05;
   //深水炸弹
   public class Bomb extends SeaObject {
       public Bomb(int x,int y){
           super(9,12,x,y,3);
       }
       public void move(){
           y+=speed;
       }
   }

2. 设计Images图片类，设计战舰图片、侦察潜艇图片、鱼雷潜艇图片、水雷潜艇图片、水雷图片、深水炸弹图片、海洋图片、游戏结束图片，并在静态块中赋值，设计main方法测试图片是否读取成功
 

  参考代码：

   ```java
   package day05;
   import javax.swing.ImageIcon;
   //图片类
   public class Images {
       public static ImageIcon battleship; //战舰
       public static ImageIcon obsersubm;  //侦察潜艇
       public static ImageIcon torpesubm;  //鱼雷潜艇
       public static ImageIcon minesubm;   //水雷潜艇
       public static ImageIcon mine;       //水雷
       public static ImageIcon bomb;       //深水炸弹
       public static ImageIcon sea;        //海洋图
       public static ImageIcon gameover;   //游戏结束图
       static{
           battleship = new ImageIcon("img/battleship.png");
           obsersubm = new ImageIcon("img/obsersubm.png");
           torpesubm = new ImageIcon("img/torpesubm.png");
           minesubm = new ImageIcon("img/minesubm.png");
           mine = new ImageIcon("img/mine.png");
           bomb = new ImageIcon("img/bomb.png");
           sea = new ImageIcon("img/sea.png");
           gameover = new ImageIcon("img/gameover.png");
       }
   
       public static void main(String[] args){
           System.out.println(battleship.getImageLoadStatus());
           System.out.println(obsersubm.getImageLoadStatus());
           System.out.println(torpesubm.getImageLoadStatus());
           System.out.println(minesubm.getImageLoadStatus());
           System.out.println(mine.getImageLoadStatus());
           System.out.println(bomb.getImageLoadStatus());
           System.out.println(sea.getImageLoadStatus());
           System.out.println(gameover.getImageLoadStatus());
       }
   }