Java | oojava04面向对象与关键字

原创已于 2025-03-16 17:22:58 修改 · 1.2k 阅读

19 ·

CC 4.0 BY-SA版权

文章标签：

#java #intellij idea

于 2025-03-16 17:09:16 首次发布

软件开发专栏收录该内容

7 篇文章

订阅专栏

oojava04

完成Point类，演示访问控制修饰符的用法
完成StaticVar、StaticBlock、StaticMethod，StaticDemo，演示static关键字的用法
完成StaticFinalDemo，演示static final常量的用法

访问控制修饰符

package和import
- package：声明包
  - 作用：避免类的命名冲突
  - 规定：同包中的类不能同名，但不同包中的类可以同名。
  - 类的全称：包名.类名。包名常常有层次结构
  - 建议：包名所有字母都小写
- import：导入类
  - 同包中的类可以直接访问，但不同包中的类不能直接访问，若想访问：
    - 先import导入类，再访问类。（建议）
    - 类的全称。（太繁琐、不建议）
访问控制修饰符：保护数据的安全（隐藏数据、暴露行为），实现封装
- public：公开的，任何类；
- private：私有的，本类；
- protected：受保护的，本类、派生类、同包类；
- 默认的：什么也不写，本类、同包类。（java不建议）
- 注意：
  - 访问权限由低到高依次为：private<默认的<protected<public；
  - 类的访问权限只能是public或默认的，类中成员的访问权限如上4种都可以。
接口中的成员的默认权限为public。
重写方法时派生类方法的访问权限必须大于或等于超类方法的。
匿名内部类中不能修改外面局部变量的值，因为该变量在此处会默认为final的。
接口：void show();抽象方法，默认public abstract，最常用。
文档注释：
- 以/**开始，以*/结束；
- 加在类、方法和常量的前面，用于说明作者，时间，版本，要实现功能的详细描述等信息。

代码

Point.java

package oojava04;
/**
 * 标准JavaBean的规范：
 * 1.成员变量私有，同时提供对应的公开的getter/setter
 * 2.包含公开的无参构造方法
 */
public class Point {
    private int x;
    private int y;
    public Point(){
    }
    public int getX(){ //getter
        return x;
    }
    public void setX(int x){ //setter
        this.x = x;
    }
    public int getY(){
        return y;
    }
    public void setY(int y){
        this.y = y;
    }
}

GetterSetterDemo.java

package oojava04;

/**
 * getter/setter的测试类
 */
public class GetterSetterDemo {
    public static void main(String[] args) {
        Point p = new Point();
        p.setX(100);
        p.setY(200);
        System.out.println(p.getX()+","+p.getY());
    }
}

Aoo.java

package oojava04;
/**
 * 访问控制修饰符的演示
 */
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; //编译错误
    }
}

Coo.java

package oojava04_vis;
import oojava04.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{ //跨包继承
    void show(){
        a = 1;
        b = 2;
        //c = 3; //编译错误
        //d = 4; //编译错误
    }
}

结果

GetterSetterDemo.java

100,200

static关键字

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

代码

StaticVar.java

package oojava04;

/**
 * 静态变量
 */
public class StaticVar {
    int a; //实例变量
    static int b; //静态变量
    StaticVar(){
        a++;
        b++;
    }
    void show(){
        System.out.println("a=" + a + ",b=" + b);
    }
}

StaticBlock.java

package oojava04;

/**
 * 静态块
 */
public class StaticBlock {
    static{
        System.out.println("静态块");
    }
    StaticBlock(){
        System.out.println("构造方法");
    }
}

StaticMethod.java

package oojava04;

/**
 * 静态方法
 */
public class StaticMethod {
    int a; //实例变量（对象来访问），属于对象的
    static int b; //静态变量（类名来访问），属于类的

    //静态方法何时用：方法的操作与对象无关（不需要访问对象的属性 / 行为）
    //在say()中需要访问对象的属性a，所以认为say的操作与对象有关，不适合设计为静态方法
    void say(){
        System.out.println(a);
    }
    //在plus()中不需要访问对象的属性 / 行为，所以认为plus的操作与对象无关，可以设计为静态方法
    static int plus(int num1, int num2){
        return num1 + num2;
    }

    void show(){ //有隐式this
        System.out.println(this.a);
        System.out.println(StaticMethod.b);
    }
    static void test(){ //没有隐式this
        //静态方法中没有隐式this传递
        //没有this就意味着没有对象
        //而实例变量a必须通过对象来访问
        //所以如下语句发生编译错误
        //System.out.println(a); //编译错误，静态方法中不能直接访问实例成员
        System.out.println(StaticMethod.b);
    }
}

StaticDemo.java

package oojava04;

/**
 * static的测试类
 */
public class StaticDemo {
    public static void main(String[] args) {
        StaticVar o1 = new StaticVar();
        o1.show();
        StaticVar o2 = new StaticVar();
        o2.show();
        StaticVar o3 = new StaticVar();
        o3.show();
        System.out.println(StaticVar.b); //常常通过类名点来访问
        System.out.println("-------------------------------");

        StaticBlock o4 = new StaticBlock(); //加载类时自动执行静态块
        StaticBlock o5 = new StaticBlock();
        StaticBlock o6 = new StaticBlock();
        System.out.println("-------------------------------");

        StaticMethod.test(); //常常通过类名点来访问
    }
}

结果

a=1,b=1
a=1,b=2
a=1,b=3
3
-------------------------------
静态块
构造方法
构造方法
构造方法
-------------------------------
0

static final常量

final：最终的、不能改变的。（单独应用几率低）
- 修饰变量：变量不能被改变
- 修饰方法：方法不能被重写
- 修饰类：类不能被继承
static final常量：应用率高
- 必须声明同时初始化
- 常常通过类名点来访问，不能被改变
- 建议：常量名所有字母都大写，多个单词之间用_分隔
- 编译器在编译时，会将常量直接替换为具体的数，效率高
- 何时用：在程序运行过程中数据永远不变，并且经常使用

代码

Eoo.java

package oojava04;
/**
 * final: 最终的、不能改变的
 * 修饰变量：变量不能被改变
 */
public class Eoo {
    final int a = 5;
    int b = 6;
    void test(){
        b = 66;
        final int c = 8;
    }
}

/**
 * 修饰方法：方法不能被重写
 */
class Foo{
    final void show(){}
    void test(){}
}
class Goo extends Foo{
    //void show(){} //编译错误
    void test(){}
}
/**
 * 修饰类：类不能被继承
 */
final class Hoo{}
class Joo{}
final class Koo extends Joo{}

StaticFinalDemo.java

package oojava04;

/**
 * static final常量的演示
 */
public class StaticFinalDemo {
    public static void main(String[] args) {
        System.out.println(Loo.PI); //常常通过类名点来访问
        //Loo.PI = 3.1415926; //编译错误，常量不能被改变

        //1)加载Loo.class到方法区中
        //2)静态变量num一并存储到方法区中
        //3)到方法区中获取num的值并输出
        System.out.println(Loo.num);

        //编译器在编译时会将常量直接替换为具体的数，效率高
        //相当于System.out.println(5);
        System.out.println(Loo.COUNT);
    }
}

class Loo{
    public static int num = 5; //静态变量
    public static final int COUNT = 5; //常量
    public static final double PI = 3.14159;
    //public static final int NUM; //编译错误，常量必须声明同时初始化
}