Java Lecture 6：Package import 访问修饰符 final和static，静态代码块以及图片加载方式

qq030928

已于 2023-11-05 15:07:41 修改

阅读量59

点赞数

分类专栏： Java学习文章标签： java 开发语言

于 2023-11-04 17:36:25 首次发布

本文链接：https://blog.csdn.net/m0_47407301/article/details/134217877

版权

Java学习专栏收录该内容

16 篇文章 0 订阅

订阅专栏

一、Package（包）

如果没有包,一个大的项目,可能需要创建很多很多类文件,如果类名是唯一标识的话,很有可能会出现文件名的冲突。

1000个类如果想1000个类名太麻烦了,所以Java设计了package。

作用：避免类名的冲突

现象：同包中的类名不可以冲突,不同包的类名不影响。

包名：要求纯小写(规范), 写包名要按照 域名反写.项目名称.模块名称.类名

域名反写：比如www.baidu.com，那就反写成com.baidu

项目名称：比如submaring

模块名称：公司会具体说

类的全包名：域名反写.项目名称.模块名称.类名

二、import(导入)关键字

什么时候需要使用到import：

1.当前需要使用的这个类,不在同一个包下,则需要通过import来导入类的全包名才可以使用。

有的时候不知道在哪里找到这个包，直接把鼠标移到类名，然后alt+回车+回车，就能直接实现自动导入。

2.同一个包下,则无需导包，直接使用即可。

使用java提供的一些功能时,有一些包如果不导包是不可以使用的。

三、访问修饰符

方法的封装：将重复的业务逻辑封装到方法里面,可以达到复用。

类的封装：将一类别下多个对象共有的属性和行为封装到模板类中。

属性的封装：用来隐藏一些内容,不让外部完全访问,若访问,也可以有条件的让对方使用。保证程序的健壮性,合法性,安全性。

属性私有化,方法公开化(比较重要的属性不能够让外部直接访问,外部若想访问,需要通过对应属性 get(获取) / set(设置) 方法来访问)

访问修饰符可以修饰我们的类(一般不需要，一般默认公开),方法，属性。

1.public:公开的,访问权限最大,任意位置都可以访问。（哪里都能调用）

2.private:私有的,访问权限最小,只能当前类内容可用。（别的地方都无法访问）

这种就是防止被修改，保护当前的属性。

3.默认的：什么都不用写的修饰符，访问权限本类和同包类都可以访问。（经常干的事）

4.protected：保护的,访问权限在本类.同包类,不同包的子类都可以访问。一般都在继承关系的父类中使用。

例子：

class  Wife{ //老婆类
   private String name = "王小花";     //属性私有化
   private int age = 18;  //属性私有化
    
   public String getName(){//方法公开化
       return "王小花";
   } 
   
   public void setAge(int age){//方法公开化
       if(age < 25 && age >18){
           this.age = age;
       } 
   }      
}

Wife  w = new Wife();

（重要）详细的访问修饰符范围可以参考下方表格：

访问修饰符           类内部         同包类/子类      非同包子类       非同包类
 public              √               √              √             √
 protected           √               √              √
 默认的               √               √
 private             √

四、final关键字

能修饰方法、类和属性

代表最终的意思

也是用来修饰类成员的。

只需要知道修饰完之后有什么特点就好了。

放在访问修饰符的后面

1.修饰的属性：用final修饰的属性,不能够二次修改! 且声明final的属性时,必须初始化赋值

不能先声明后赋值，要同时！

2.修饰的方法：用final修饰的方法,不能够被重写！一般应用在父类级别的代码中。有一些功能，不想要子类继承的时候就用。

3.修饰的类：用final修饰的类,不能够被继承的！相当于断子绝孙，放在类名的前面。

被继承就有被修改的风险。

例子：

package oo.day03;

/**
 * final的测试使用演示类：
 */
public class FinalDemo {
    public int a;//普通的成员变量无需初始化赋值
    public final int b = 100;//声明final的变量需要初始化赋值。
    public void fun(){
        a = 10;
        a = 200;
//        b = 500; 用final修饰的变量 不可二次修改。
    }
}
final class Aoo{ //final修饰的类
   public final void sayHi(){ //final修饰的方法

    }
}
class Boo extends Aoo{ //子类 被final修饰的类 无法被继承
//   public void sayHi() {//被final修饰的方法 无法 被重写
//
//    }
}

五、static关键字

每个人相当于每个对象，那手里拿的杯子,属于个人的属于对象的。

教学楼里的饮水机属于对象的吗？不属于对象,但是被对象共享。

所以可以理解为static就是类的属性和方法。static 关键字只能用于修饰类的属性和方法。

变量：

1.实例变量：成员变量就是实例变量（其实就是属性）,实例变量是属于对象的！(有多少个对象,就有多少份数据),堆中存储。通过对象访问。

2.静态变量: 用static修饰的变量称之为静态变量,属于类的(且只有一个)！用类来打点调用。

其实通过实例化对象也可以打点调用（但是从代码编写结构来说，不支持这么干）

当类在被首次使用时,则会将类对应的.class字节码文件加载到方法区中,注意,只会被加载一次！

JVM划分内存区域：
                栈区,堆区,方法区
    1.栈区放局部变量
    2.堆区放对象 
    3.方法区:用来加载.class字节码文件(类中的方法和静态方法/构造方法/静态变量)的区域。

示例代码：

package oo.day03;

/**
 * 静态的使用演示类：
 */
public class StaticDemo {
    public static void main(String[] args) {
        Coo c1 = new Coo();
        c1.show();
        Coo c2 = new Coo();
        c2.show();
        Coo c3 = new Coo();
        c3.show();
    }
}
class Coo {
    int a;//属性--->成员变量---->实例变量！ 属于对象的！每个对象有自己独立的
    static int b;//静态变量  属于类的！只有一份 被当前类对象共享
    Coo() {
        a++;
        b++;
    }
    void show() {
        System.out.println("a的数据为：" + a + ",b的数据为:" + b);
    }
}

上方这段代码，b的值是每运行一次，都会自动增加。

所以其实static关键字就是让属性变成类共享的属性，而不是实例变量。

静态适用性：

当有一份数据需要被某个类别下的所有对象共享时,可以将这份数据作为静态的。

例子：

当有一张水雷潜艇图片需要被水雷潜艇类对象使用时,可以将这张图片做成静态资源。

可以节省内存

静态方法：

1.用static 修饰的方法称之为静态方法。属于类的,通过类名打点调用。

2.存储在方法区中。

3.静态方法内容是没有隐式this传递的！无法访问实例成员！

可以这么理解，静态方法是类的方法，所以静态方法里出现的参数，都应该是类里的参数，不能是实例的参数（this.属性），因为类无法访问到实例成员。

所以在下面这段代码里，为什么我们要创建一个action方法，在里面实例化gameworld的属性，是因为gameworld的属性都是gameworld的实例变量，而main方法是static的，它只能访问类的方法和类的static属性，无法访问实例变量！！所以我们在这写了一个类的action方法，通过类打点去调用它，实现gameworld里的潜艇类炸弹类等的实例化。

public class GameWorld extends JPanel {//当前测试类继承 JPanel
    Battleship ship; //声明一个战舰类型的变量
    Bomb[] bombs;//声明一个深水炸弹数组类型的变量
    SeaObject[] submarines;//代表三种潜艇类型(侦察潜艇,水雷潜艇,鱼雷潜艇)
    SeaObject[] thunders;//代表二中雷类型(水雷,鱼雷)

    void action() {
        ship = new Battleship();//为战舰类创建战舰对象 并存储在ship这个变量里
        submarines = new SeaObject[9];

    public static void main(String[] args) {
        GameWorld gw = new GameWorld();
        gw.paintWorld();//调用绘制窗口的方法
        gw.action();
    }

适用性：静态方法适用于工具内容逻辑的方法，目的就是为了外部方便使用，直接通过类名点的形式就可以使用。相当于封装，能够在不实现实例的情况下，进行方法的调用。

比如Math.random()就是在调用Math类的random方法。不想要别人改变这个方法，就使用static。

static void test() {//静态的方法中,没有隐式this传递的！所有在静态方法中,无法访问实例的成员(实例变量、普通方法)
                                    //报错,没有this传递。
    // System.out.println("a的数据为：" + this.a + ",b的数据为:" + Coo.b);

}

项目思考：项目中很多类别都有对应的图片，例如：侦察潜艇类别下的所有对象都需要一张侦察潜艇图片。如果每个类别下的图片想要达到对应类别共享的话，都需要做成静态图片类型。

设计原则：类的单一职责，当前图片加载的操作，我们应该单独再去做一个类，用于项目中所有图片的加载。

所以这里我们创建一个ImageResources类文件，通过这个类去加载游戏中会用到的资源。

静态代码块：

语法结构：
要写在类里面

static{

}

1.用static修饰的代码块称之为静态代码块

2.属于类的,当前类在被第一次加载时,静态代码块也会执行。只会执行一次.

3.如果创建类对象时,有静态代码块和构造方法时,会执行静态代码块的内容。

4.就算类访问的是静态成员,如果是第一次用该类,也会被加载。

package oo.day03;

/**
 * 静态的使用演示类：
 */
public class StaticDemo {
    public static void main(String[] args) {
        Coo.b = 10;//当类被使用时,就会被加载到方法区中。对应类的静态代码块 则会执行
        new Coo();
    }
}
class Coo {
    int a;//属性--->成员变量---->实例变量！ 属于对象的！每个对象有自己独立的
    static int b;//静态变量  属于类的！只有一份 被当前类对象共享
    Coo() {
        System.out.println("Coo类的构造方法");
    }
    static {//静态代码块
        System.out.println("Coo类静态代码块执行了");
    }

}

六、如何加载图片

在项目包下创建一个图片加载资源类：

ImageResource

package cn.tedu.submarine;

import javax.swing.*;（不用自己导入，打一个ImageIcon就能实现自动导入了）

/**
 * 图片资源加载类:
 *              负责加载和初始化项目中所需要的图片
 * */
public class ImageResources {
    //ImageIcon 用来存图片资源的类型
    //1. 先声明
    public static ImageIcon battleShip;//用来存战舰图片的变量
    public static ImageIcon bomb;//用来存深水炸弹图片的变量
    public static ImageIcon gameover;//用来存储游戏结束图片的变量
    public static ImageIcon mine;//用来存储水雷图片的变量
    public static ImageIcon minesubm;//用来存储水雷潜艇图片的变量
    public static ImageIcon obsersubm;//用来存储侦查潜艇图片的变量
    public static ImageIcon sea;//用来存海洋背景图片的变量
    public static ImageIcon start;//用来存游戏开始图片的变量
    public static ImageIcon torpedo;//用来存鱼雷图片的变量
    public static ImageIcon torpedosubm;//用来存储鱼雷潜艇的变量
    //2. 赋值
    static{//静态代码块 当类被加载时 执行 代码块中的内容。
        battleShip = new ImageIcon("img/battleship.png");
        bomb = new ImageIcon("img/bomb.png");
        gameover = new ImageIcon("img/gameover.png");
        mine = new ImageIcon("img/mine.png");
        minesubm = new ImageIcon("img/minesubm.png");
        obsersubm = new ImageIcon("img/obsersubm.png");
        sea = new ImageIcon("img/sea.png");
        start = new ImageIcon("img/start.png");
        torpedo = new ImageIcon("img/torpedo.png");
        torpedosubm = new ImageIcon("img/torpesubm.png");
    
    }

}

1. 声明变量

2. 赋值（因为ImageIcon是一个类)，所以这里直接实例化一个ImageIcon并赋值给battleship，后面括号里是路径（相对路径）

3.这里用static关键字是为了每一次类被加载，或者每一次类的实例被调用，就执行一次代码块里的内容。实现图片的反复显示。

4. 并且！在这之后，需要把每个图片变量打印出来。如果结果是8，说明图片能正常加载。如果是4，说明变量出现错误，需要检查代码，以确保这个图片能正常显示。

qq030928

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
1
评论
Java Lecture 6：Package import 访问修饰符 final和static，静态代码块以及图片加载方式

Java Lecture 6：Package import 访问修饰符 final和static，静态代码块以及图片加载方式
复制链接

扫一扫