Java面向对象（常用关键字，包，访问权限修饰符）

最新推荐文章于 2024-09-08 11:09:43 发布

刘思睿(昵称已存在)

最新推荐文章于 2024-09-08 11:09:43 发布

阅读量540

点赞数 11

文章标签： java 开发语言

本文链接：https://blog.csdn.net/2301_78341216/article/details/136991768

版权

本文详细讲解了Java中的this关键字在引用成员变量、方法和构造函数中的用法，介绍了static关键字的定义、特点和静态成员的使用，以及访问权限修饰符（public、protected、default和private）的作用和适用场景。

摘要由CSDN通过智能技术生成

3.（default）（默认的，实际应用中可写可不写）

4.private（私有的）

一、this关键字

1.含义：

Java语言中的this关键字表示的是当前正在访问的对象

2.作用：

（1）用this关键字引用成员变量

常常用来区分成员变量和局部变量

例如：一个有参构造函数中的参数名与成员变量名一致时，使用this关键字进行标记，以免错误赋值。

正确示例：

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

public Person(String name,int age,String gender){
         this.name = name;
         this.age = age;
         this.gender = gender;
    }
}

如果没有使用this关键字说明赋值的是成员变量，根据就近原则，系统默认使用传进来的参数（局部变量），相当于自己赋给自己，并没有把值赋给成员变量，程序会报错。

错误示例：

public Person(String name,int age,String gender){
        name = name;//错误编写，程序会报错
        age = age;
        gender = gender;
    }

（2）用this关键字引用成员方法

public void Work(){
        System.out.println("工作");
    }
public void print(){
        System.out.println("name:"+this.name+" age:"+this.age+" gender:"+this.gender);
        //用this关键字引用成员方法
        this.Work();//相当于person.work（）
    }

（3）用this关键字引用构造方法

public Person() {//用this关键字引用构造方法
        this("jake", 17, "男");
    }
public static void main(String[] args) {
        Person person = new Person("张三",15,"男");
        person.print();
    }

二、static关键字

1.定义

static被称为静态，可以用来修饰 类的成员变量 , 成员方法 , 代码块 , 内部类。

static 修饰的方法或者变量不需要依赖于对象来进行访问，只要这个类被加载，静态成员

就会被加载创建。

2.特点

• 随着类的加载而加载

• 优先于对象存在

• 修饰的成员，被所有对象所共享（共享即不管创建了多少个对象，静态属性在内存中只有一个）

• 可不创建对象，直接使用类名调用

3.静态成员变量

• 静态变量在类被加载时由系统默认初始化。

• 静态变量值是所有对象共享。

• 静态变量可创建对象调用，也可不创建对象，直接由类名调用。（格式为：类名.变量名）

public class Chinese {
    String name;
    static String from = "中国";//静态变量,静态属性在内存中只有一份，所有对象共享，减少内存占用
    String gender;
    static int count = 0;//静态成员
    public Chinese(){
        count = count+1;
    }

  public static void main(String[] args) {
      System.out.println(Chinese.count);
      System.out.println(Chinese.from);//建议使用类名直接访问静态的成员
  }
}

4.静态方法

（1）static修饰的方法称为静态方法，直接用类名调用

（2）静态方法中，只能使用静态成员变量，因为他们随着类的加载而加载

public class MethodDemo {
    static int i = 0;
    String name;
   public static void test(){
        System.out.println(i);  //静态成员
        //System.out.println(this.i);
        //System.out.println(name);  非静态成员
   }
   public void person(){
        System.out.println("吃饭");
        System.out.println(i);//非静态方法可以使用静态成员变量
   }

}

（3）非静态成员要想使用就要创建对象

public class MethodDemo {
    static int i = 0;
    String name;
    public void person(){
        System.out.println("吃饭");
    }

    public static void test(){ //静态方法
        System.out.println(i);
    }

    public static void main(String[] args) {
        MethodDemo p = new MethodDemo(); //非静态成员要想使用就要创建对象
        p.person();
        MethodDemo.test(); //静态方法直接用类名调用

注：因为不需要实例就可以访问static方法，因此static方法内部不能有this和super。

三、代码块

代码块是在类中声明一个没有名字的方法体

1.实例代码块（实例块）

实例块在每次创建对象时被调用

 {
        //填写任何符合Java语法的代码，如：
        System.out.println("实例代码块1");
 }

2.静态代码块（静态块）

静态块在类被加载时调用，并且仅被调用一次，与是否创建对象无关。

static {
        //任何符合JAVA语法的代码
        System.out.println("静态代码块1");
    }

四、包

现实应用中，对于Java程序的编写不可能只局限于几个类。

随着程序架构越来越大，类的种类也大大增加。

这时，程序员为了有效管理区分各种各样的类（最关键的便是同名类），于是便在JAVA语言中引入了包（package）的机制。

通过包对各种类进行打包区分，十分有效的解决了同名类和类管理等问题。

每个类属于一个特定的包,所以java中一个类的完整名称等于包名+类名

1.包的作用：

●按照不同功能管理类

●避免类重名

●控制访问权限

2.包的命名规范

在包名中，可以使用 . 号来区分包的级别；包名一般情况下是小写

（1）第一级指该项目的类型，如com,org,gov等。

（2）第二级指项目所开发或者运行的公司名称，如：oracle , sun , huawei 等。

（3）第三级指项目的名称，如：bcms,oa,erp,cms等。

（4）第四级指项目模块的名称，如：bean,action,exception等。

3.导入外部包的类

如果要在本包的类中使用别的包中的类用 import 关键字来导入。

package test.test2;
import test.test1.Demo1;//本包test2中的类Demo2使用了
                          外部包test1中的类Demo1
public class Demo2 {
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
        demo1.apple = "zz";
        demo1.print();
    }
}

五、访问权限修饰符

通过给类中属性添加不同的访问权限修饰符，来改变该属性在同类，不同类，跨包类等环境下是否能被使用的情况。

1.public（公共的）

公共权限修饰类、成员变量、成员方法，内部类。可以在任意类中访问

本包同一类

package test.test1;
public class Demo1 {
    public String apple = "aa";//公共权限 修饰类、成员变量、成员方法，内部类。可以在任意类中访问
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
        demo1.apple = "zz";  //本包同一类
    }
}

本包不同类

package test.test1;
public class TestDemo {  //本包不同类
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
        demo1.apple = "zz";
    }
}

外部包的无关类

package test.test2;
import test.test1.Demo1;
public class Demo2 {  //外部包无关类
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
        demo1.apple = "zz";
    }
}

外部包的子类（用extends关键字继承本包类）

package test.test2;
import test.test1.Demo1;
import test.test1.TestDemo;
public class TestDemot extends Demo1 {  //外部包子类
    public static void main(String[] args) {
        TestDemot testDemot = new TestDemot();
        testDemot.apple = "nn";
    }
}

接下来三种类型在本类中的情况就不多做赘述了，这里只展示其他情况。

2.protected（受保护的）

受保护的权限修饰成员变量、成员方法，内部类。可以在同包类访问.其他包中的子类也可访问

同包类

package test.test1;
public class TestDemo {  //同包类
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
        demo1.banana = "xx";
    }
}

其他包子类

package test.test2;
import test.test1.Demo1;
import test.test1.TestDemo;
public class TestDemot extends Demo1 {
    public static void main(String[] args) {
        TestDemot testDemot = new TestDemot();
        testDemot.banana = "mm";
    }
}

3.（default）（默认的，实际应用中可写可不写）

默认权限修饰类、成员变量、成员方法，内部类。在本类和本包的其他类可以被访问

本包其他类

package test.test1;
public class TestDemo {   //本包其他类
    public static void main(String[] args) {
        Demo1 demo1 = new Demo1();
        demo1.carrot = "cc";
    }
}

4.private（私有的）

私有权限修饰成员变量、成员方法，内部类。只能在本类中被访问！

本篇关于两个常用的关键字以及访问权限修饰符等知识的介绍到这里就结束了。希望本篇内容对您有所帮助，带来收获，同时也感谢您的阅读并期待我为大家带来更多学习内容。

刘思睿(昵称已存在)

关注

11
点赞
踩
14

收藏

觉得还不错? 一键收藏
1
评论
Java面向对象（常用关键字，包，访问权限修饰符）

static被称为静态，可以用来修饰类的成员变量 , 成员方法 , 代码块 , 内部类。static 修饰的方法或者变量不需要依赖于对象来进行访问，只要这个类被加载，静态成员就会被加载创建。2.特点• 随着类的加载而加载• 优先于对象存在• 修饰的成员，被所有对象所共享（共享即不管创建了多少个对象，静态属性在内存中只有一个• 可不创建对象，直接使用类名调用。
复制链接

扫一扫