JAVA定义方法前不写访问修饰符 java方法不加修饰符

转载

码海舵手 2024-02-08 06:16:16

文章标签 JAVA定义方法前不写访问修饰符修饰符赋值子类 文章分类 Java 后端开发

1.Java语言提供了很多修饰符，主要分为以下两类：

访问修饰符

非访问修饰符

修饰符用来定义类、方法或者变量，通常放在语句的最前端。我们通过下面的例子来说明：

public class className {
   // ...
}
private boolean myFlag;
static final double weeks = 9.5;
protected static final int BOXWIDTH = 42;
public static void main(String[] arguments) {
   // 方法体
}

2.访问控制修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

public : 对所有类可见。使用对象：类、接口、变量、方法。

protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）。

default (即缺省，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

private : 在同一类内可见。使用对象：变量、方法。注意：不能修饰类（外部类）。

我们可以可以通过以下表来说明访问权限：

修饰符	当前类内部	同一包内	子孙类	其他包	其他包子孙类
public	Y	Y	Y	Y	Y
protected	Y	Y	Y	N	Y/N
default（缺省）	Y	Y	N	N	N
private	Y	N	N	N	N

3.非访问修饰符

为了实现一些其他的功能，Java 也提供了许多非访问修饰符。

static 修饰符，用来修饰类方法和类变量。

final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。

abstract 修饰符，用来创建抽象类和抽象方法。

synchronized 和 volatile 修饰符，主要用于线程的编程。

3.1 static 修饰符

静态变量：

static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。静态变量也被称为类变量。局部变量不能被声明为 static 变量。

静态方法：

static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

对类变量和方法的访问可以直接使用 classname.variablename 和 classname.methodname 的方式访问。

如下例所示，static修饰符用来创建类方法和类变量。

public class InstanceCounter {
   private static int numInstances = 0;
   protected static int getCount() {
      return numInstances;
   }
 
   private static void addInstance() {
      numInstances++;
   }
 
   InstanceCounter() {
      InstanceCounter.addInstance();
   }
 
   public static void main(String[] arguments) {
      System.out.println("Starting with " +
      InstanceCounter.getCount() + " instances");
      for (int i = 0; i < 500; ++i){
         new InstanceCounter();
          }
      System.out.println("Created " +
      InstanceCounter.getCount() + " instances");
   }
}
以上实例运行编辑结果如下:
Started with 0 instances
Created 500 instances

3.2 final 修饰符

final从字面上理解含义为“最后的，最终的”。在Java中也同样表示出此种含义。final可以用来修饰变量（包括类属性、对象属性、局部变量和形参）、方法（包括类方法和对象方法）和类。

① final修饰类:

final修饰类即表示此类已经是“最后的、最终的”含义。因此，用final修饰的类不能被继承，即不能拥有自己的子类。

如果视图对一个已经用final修饰的类进行继承，在编译期间或发生错误。

② final修饰方法：

final修饰的方法表示此方法已经是“最后的、最终的”含义，亦即此方法不能被重写（可以重载多个final修饰的方法）。

此处需要注意的一点是：因为重写的前提是子类可以从父类中继承此方法，如果父类中final修饰的方法同时访问控制权限为private，将会导致子类中不能直接继承到此方法，因此，此时可以在子类中定义相同的方法名和参数，此时不再产生重写与final的矛盾，而是在子类中重新定义了新的方法。

public class B extends A {
 
     public static void main(String[] args) {
 
     }
 
     public void getName() {
         
     }
 }
 
 class A {
 
     /**
      * 因为private修饰，子类中不能继承到此方法，因此，子类中的getName方法是重新定义的、
      * 属于子类本身的方法，编译正常
      */
     private final void getName() {
         
     }
 
     /* 因为pblic修饰，子类可以继承到此方法，导致重写了父类的final方法，编译出错
     public final void getName() {
     
     }
     */
 }

③ final 修饰变量：

final修饰的变量表示此变量是“最后的、最终的”含义。一旦定义了final变量并在首次为其显示初始化后，final修饰的变量值不可被改变。

3.3 abstract 修饰符：后续讲解

3.4 synchronized 修饰符：后续讲解

3.5 transient 修饰符：后续讲解

3.6 volatile 修饰符：后续讲解

4.说明

4.1 static 修饰符：代表静态的，可用于修饰属性、方法、代码块，内部类。

(1) static 修饰的属性（静态变量或类变量）：

① 随着类的加载而加载，随着类的消失而消失(生命周期最长)。

② static修饰的属性被所有该类的对象所共享

③ 一旦某个对象改变该属性值，其他对象该属性值也会随之改变

④ 静态变量的存在优先于对象

⑤ 可以通过 "类名.类变量"的方式调用

(2) static 修饰的方法（静态方法或类方法）：

① 随着类的加载而加载

② 静态方法的存在优先于对象

③ 可以通过"类名.类方法"的方式调用

④ 静态方法中不能调用非静态成员

⑤ 静态方法不能使用 this 和 super

(3) static 修饰的代码块

① 静态代码块

① 格式： static{}

② 随着类的加载而加载，并且只加载一次

③ 静态代码块的执行优先于非静态代码块

④ 静态代码块中不能调用非静态成员

⑤ 静态代码块可以有多个，依次向下的顺序执行

② 非静态代码块

① 格式：类中的一对 {}

② 在每次创建对象时被调用

③ 非静态代码块的执行优先于构造器

④ 用于为对象初始化。（通常为共性内容进行初始化）

⑤ 非静态代码块可以有多个，依次向下的顺序执行

(4) 内部类

① 静态内部类

public class Hello {
    static int a = 2; 
       public static void main(String[] args){
            //  new newHello().count(); 
            System.out.println(new newHello().b); 
        }  
       public static class newHello{ 
           int b = 3; 
           public void count(){   
           System.out.println(a); 
           }     
       }  
}

② 非静态内部类

public class Hello {
    int a = 2;
    public static void main(String[] args){
        new Hello().new newHello().count();
    }
   public class newHello {
       public void count(){
           new Hello().a = 1;
           System.out.println("aaa");
       }
   }
}

(5) 为属性赋初始值的方式顺序：

① 默认赋值

② 直接显示赋值

③ 代码块（静态代码块非静态代码块）

④ 构造器

4.2 final 修饰符：代表最终的，可用于修饰方法变量、类。

① final 修饰的类不能被继承

② final 修饰的方法不能被重写

③ final 修饰的变量叫常量，一旦被赋值，值不能改变。

说明：命名规范

① 所有字母都大写，每个单词之间以 "_” 分隔

② 常量没有默认值。在使用前必须赋值(直接显示赋值、构造器、代码块)