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 : 在同一类内可见。使用对象:成员变量、成员方法。 注意:不能修饰外部类和接口
修饰符当前类同一包内子孙类(同一包)子孙类(不同包)其他包
publicYYYYY
protectedYYYY/N(说明N
default(缺省)YYYNN
privateYNNNN

 

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

所有的访问修饰符和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 修饰符可以应用于四个访问修饰符。

 

 

 

 

 

 

 

 

 

 

 

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值