java 判断方法修饰符 反射 java方法的修饰符有哪些

目录

 

Java修饰符

一、访问修饰符

(1)访问变量的方式

(2)四种访问修饰符的区别:

(1)public修饰符

(2)protected修饰符

(3)default修饰符

(4)private修饰符

二、非访问修饰符

(1)static 修饰符

静态变量：

静态方法：

(2)final 修饰符

(1)final 变量：

(2)final 方法

(3)final 类

(3)abstract 修饰符

抽象类：

抽象方法

(4)synchronized 修饰符

---

Java修饰符

像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符：

• 访问修饰符 :public , protected, default, private
• 非访问修饰符 : final, abstract, static, synchronized

 

一、访问修饰符

• public : 对所有类可见。使用对象：类、接口、成员变量、成员方法
• protected : 对同一包内的类和所有子类可见。使用对象：成员变量、成员方法。 注意：不能修饰外部类和接口。
• default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、成员变量、成员方法。
• private : 在同一类内可见。使用对象：成员变量、成员方法。 注意：不能修饰外部类和接口

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

 

访问修饰符不能用于局部变量

所有的访问修饰符和abstract,static,不能修饰局部变量(即成员方法里定义的变量)

 

(1)访问变量的方式

(1)在子类中直接访问父类的成员变量和成员方法

(2)通过类创建的对象来访问成员变量和成员方法

(2)四种访问修饰符的区别:

• 1,假设public的类A里有个public变量a,那么A在任何包里创建的对象都可以访问a,继承的子类所创建的对象,也可以访问a
• 2,假设public的类B里有个protect变量b,那么B在外包里创建的对象不能访问b,因为b只在同一个包里可见,只有在外包里继承了B,才能在那个子类里访问b   (如何在包内继承,那完全可以访问,因为变量包内可见)
• 3,假设public的类C里有个缺省修饰符的变量c,那么C在外包里创建的对象也是无法访问c的,因为c只在同一个包里可见,即便是在外包中继承了C的子类里,也不能访问c   (如何在包内继承,那完全可以访问,因为变量包内可见)
• 4,假设public的类D里有个private的变量d,就更不用说了,d在同一个包里也是不可见的,只有在当前类中可见    (d在包内也无法继承)
• 1.对于public修饰的类,可用于一切包,需要import一下
• 2.对于缺省修饰词的类,只在同包可见(同包也没有必要import)

(1)public修饰符

允许所有的包访问,是安全级别最低的修饰符

Java 程序的 main() 方法必须设置成公有的，否则，Java 解释器将不能运行该类。

public static void main(String[] arguments) {
   // ...
}

(2)protected修饰符

• 基类的 protected 成员是包内可见的，并且对子类可见；
• 若子类与基类不在同一包中，那么在子类中，子类实例可以访问其从基类继承而来的protected方法，而不能访问基类实例的protected方法
• 从基类继承来的子类的pro方法,只对子类本身和重子类可见

也就是说,只有初代父类的pro变量对同包可见

package p1;
public class Father1 {
    protected void f() {}    // 父类Father1中的protected方法
}
 
package p1;
public class Son1 extends Father1 {}
 
package p11;
public class Son11 extends Father1{}
 
package p1;
public class Test1 {
    public static void main(String[] args) {
        Son1 son1 = new Son1();
        son1.f(); // Compile OK     ----（1）
        son1.clone(); // Compile Error     ----（2）
 
        Son11 son = new Son11();    
        son11.f(); // Compile OK     ----（3）
        son11.clone(); // Compile Error     ----（4）
    }
}



此例说明,父类和子类不在相同的包,在父类包中用子类创建的对象,可以访问   子类对象.f()   原因是父类的pro方法对同包可见,即便不是用父类对象.
而clone方法是父类从更高的祖类继承来的,只在父类本身中和子类本身中可见,在text1类中不可见

package p2;
class MyObject2 {
    protected Object clone() throws CloneNotSupportedException{
       return super.clone();
    }
}
 
package p22;
public class Test2 extends MyObject2 {
    public static void main(String args[]) {
       MyObject2 obj = new MyObject2();
       obj.clone(); // Compile Error         ----（1）
 
       Test2 tobj = new Test2();
       tobj.clone(); // Complie OK         ----（2）
    }
}


此例说明,父类子类不同包,在子类中,可以访问子类对象的pro方法,但是不能访问父类对象的pro方法.
因为父类的pro变量只对父类包可见,其继承到子类中,只能用子类创建的对象才能访问子类的pro变量

(3)default修饰符

default是一个缺省修饰符,,并不用写出来

当类和类的成员变量及成员方法缺省修饰符时,它们在同一个包内可见,,

当接口本身缺省修饰符时,会默认为default abstract而不是public abstract

当接口的变量和方法缺省修饰符时,成员变量隐式声明为 public static final,成员方法隐式声明为public abstract。

由于default修饰的类在其他包不可见,所以在其他包也就没有子类可以继承它

由public修饰的类,default修饰的变量,,这个变量在外包的子类中也是无法访问的,因为default只在包内可见

(4)private修饰符

只能在当前类中访问private变量和方法,是安全级别最高的修饰符

子类在包内和包外都不能继承父类的private方法和private变量

子类在包外不能继承父类的default方法和变量

用于封装数据:

public class Person{
    private String name;
    private int age;

    public int getAge(){
      return age;
    }

    public String getName(){
      return name;
    }

    public void setAge(int age){
      this.age = age;
    }

    public void setName(String name){
      this.name = name;
    }
}

采用 this 关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。

 

 

二、非访问修饰符

 

(1)static 修饰符

静态变量：

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

静态方法：

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

 

(2)final 修饰符

(1)final 变量：

• final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。
• final 修饰符通常和 static 修饰符一起使用来创建类常量。

public class Test{
  final int value = 10;
  // 下面是声明常量的实例
  public static final int BOXWIDTH = 6;
  static final String TITLE = "Manager";
 
  public void changeValue(){
     value = 12; //将输出一个错误
  }
}

(2)final 方法

• 父类中的 final 方法可以被子类继承，但是不能被子类重写。
• 声明 final 方法的主要目的是防止该方法的内容被修改。
• 如下所示，使用 final 修饰符声明方法。

public class Test{
    public final void changeName(){
       // 方法体
    }
}

(3)final 类

• final 类不能被继承，没有类能够继承 final 类的任何特性。

public final class Test {
   // 类体
}

(3)abstract 修饰符

抽象类：

• 抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
• 一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
• 抽象类可以包含抽象方法和非抽象方法。
• 没有抽象成员变量的说法,abstract不用于变量前面

abstract class Caravan{
   private double price;
   private String model;
   private String year;
   public abstract void goFast(); //抽象方法
   public abstract void changeColor();
}

抽象方法

• 抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。
• 抽象方法不能被声明成 final 和 static。
• 任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。
• 如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。
• 抽象方法的声明以分号结尾，例如：public abstract sample();。

public abstract class SuperClass{
    abstract void m(); //抽象方法
}
 
class SubClass extends SuperClass{
     //实现抽象方法
      void m(){
          .........
      }
}

 

(4)synchronized 修饰符

synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。