Java 类规范与声明

明湖起风了

已于 2024-07-04 11:36:05 修改

阅读量1.4k

点赞数

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

于 2022-12-09 09:42:38 首次发布

本文链接：https://blog.csdn.net/m0_47743175/article/details/128241470

版权

java 专栏收录该内容

33 篇文章 1 订阅

订阅专栏

学新也能忘旧，回顾一下java类基本信息！

类规范

类的结构组织，一般按照如下的顺序定义：

常量声明
静态变量 / 类变量声明
构造函数部分
静态方法部分
成员方法部分

声明

1. 常量声明

常量有三种类型：静态常量、成员常量、局部常量。

public class Test {
    // 静态常量
    public static final double PI = 3.14;
    // 声明成员常量
    final int x = 10;

    public static void main(String[] args) {
        // 声明局部常量
        final double y = 3.3;
    }
}

final 是定义常量的关键字，表示最终的，如果用来修饰变量，那这个变量就变成了常量。常量取名一般都用大写字符。

静态常量：使用 public static 修饰的常量作用域是全局的，不需要创建对象就可以访问它，在类外部访问形式为 HelloWorld. PI。

2. 静态变量 / 类变量声明

静态变量（类变量）就是用 static 关键字修饰的变量，特点是被该类中所有的实例对象共享。在类加载的时候就生成了。

当我们需要让某个类的所有对象都共享一个变量时，就可以考虑使用静态变量。

    public static void main(String[] args) {
        Mystatic mystatic1 = new Mystatic();
        Mystatic mystatic2 = new Mystatic();
        Mystatic mystatic3 = new Mystatic();
        mystatic1.sum++;
        mystatic2.sum++;
        mystatic3.sum++;
        System.out.println(mystatic1.sum);
        System.out.println(mystatic2.sum);
        System.out.println(mystatic3.sum);
    }

    class Mystatic{
        public static int sum = 0;
    }

3
3
3

结果，三个实例共享一个变量。

3. 构造函数部分

构造函数的作用是在对象建立时对对象初始化。也就是在创建对象时调用。

构造函数的函数名要与类名一样，且没有返回值类型。

注意：

当类中没有定义构造函数时，系统会默认添加一个无参的构造函数。如果自定义了构造函数，就不会创建默认的构造函数了。

在一个类中可以定义多个不同参数的构造函数，这就是重载的体现。构造函数名称相同参数不同。

class Mystatic{
    public static int sum = 0;

    //public修饰无参构造函数
    public Mystatic() {
    }

    //private修饰一个参数的构造函数
    private Mystatic(int test1) {
    }

    //protected修饰俩个个参数的构造函数
    protected Mystatic(int test1, int test2) {
    }

    //默认（无修饰符）+ 抛出异常
    Mystatic(int test1, int test2, int test3) throws Exception {
    }
}

作用域当前类同一package 子孙类其他package

public √ √ √ √

protected √ √ √ ×

默认 √ √ × ×

private √ × × ×

4. 静态方法部分

静态方法与静态变量类似，会被多个实例所共享，任何一个实例对静态数据成员的修改，都会影响其它实例。在类中使用static修饰，静态方法会随着类的定义而被分配和装载入内存中；而非静态方法属于对象的具体实例，只有在类的对象创建时在对象的内存中才有这个方法的代码段。

public class Test2{
    public static void main(String[] args) {
        System.out.println(Mystatic.getStatic());//使用类名加前缀访问静态方法
        Mystatic s=new Mystatic();
        System.out.println(s.getStatic());//使用实例化对象名访问静态方法
        System.out.println(s.get());
    }
    public static class Mystatic{
        public static int sum = 0;
        public String name = "fan";
        //静态方法只能访问静态数据成员
        public static int getStatic()
        {
            return 6;
        }

        //非静态方法可以访问静态方法、非静态方法、非静态数据成员和静态数据成员
        public int get()
        {
            getStatic();
            System.out.println(name);
            return 66;
        }

        //public修饰无参构造函数
        public Mystatic() {
        }

        //private修饰一个参数的构造函数
        private Mystatic(int test1) {
        }

        //protected修饰俩个个参数的构造函数
        protected Mystatic(int test1, int test2) {
        }

        //默认（无修饰符）+ 抛出异常
        Mystatic(int test1, int test2, int test3) throws Exception {
        }
    }
}

5. 成员方法部分

成员方法是类或对象的行为特征的抽象。Java中的方法不能独立存在，所有的方法必须定义在类中。使用 “类名.方法” 或 “对象.方法” 的形式调用。

public class Mystatic{
    public static int sum = 0;

    //可以使用 [public|private|protected] 修饰
    public String getStatic(){
        return "6";
    }
    public void MakeStatic(){
        System.out.println("无返回值！");
    }
    // 只能在类中使用
    private void SendStatic(){
        System.out.println("private修饰！");
    }
}

调用：

    public static void main(String[] args) {
        Mystatic mystatic = new Mystatic();
        mystatic.getStatic();
        mystatic.MakeStatic();
    }