类和对象（二）

寻星探路

发布于 2025-12-17 19:49:06

110

文章被收录于专栏：CSDN博客CSDN博客

一、包

(Package)是Java中⼀个组织类的方式,用于防止类名冲突和提⾼代码的可读性。包允许将类组织在⼀个层次结构中,类似于文件系统中的目录。

1.导入包中的类

使用import语句导⼊包

 import java.util.Date;
 public class Test {
     public static void main(String[] args) {
         Date date = new Date();
         // 得到⼀个毫秒级别的时间戳
         System.out.println(date.getTime());
     }
 }

(*就不说了，自己清楚就行，别用！！！)

2.包的访问权限

如果我们在定⼀个类的时候，如果没有指定成员变量/成员⽅法的访问权限，此时默认的访问权限就是包访问权限。

二、封装

简单来说就是套壳屏蔽细节。

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接⼝来和对象进行交互

 class Student{

     private String name; //使⽤ private  修饰  
     private int age; //使⽤private  修饰
  
     public void eat() {
         System.out.println(this.name + " 正在吃饭！");
     }

     public void show() {
         System.out.println("name: "+name+" 年龄："+age);
     }

 }
 public class Test {
     public static void main(String[] args) {
         Student stu= new Student();
     }
 }

上述代码使⽤private修饰之后，在Test类中无法通过person引用来进行访问数据，这里封装就起到了作用！

如果要想访问，此时只能手动提供get和set方法作为公开的接口来进行访问！

 class Student{
     private String name; //使⽤ private  修饰
     private int age; //使⽤private  修饰
  
     public String getName() {
         return name;
     }
    
     public void setName(String name) {
         this.name = name;
     }

     public int getAge() {
         return age;
     }

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

     public void eat() {
         System.out.println(this.name + " 正在吃饭！");
     }

      public void show() {
          System.out.println("name: "+name+" 年龄："+age);
    }

 }
 public class Test {
     public static void main(String[] args) {
         Student stu= new Student();
         stu.setAge(10);
         System.out.println(person.getAge());
     }
 }

好处：

1.封装可以降低对象和对象之间的耦合度，当对象内部发⽣变化时，只需要修改对象内部即可，不会影响到外部程序，因为公开的接口是不会发⽣改变的

2.封装是隐藏了对象内部的实现细节，只提供了公开的接口给外部，使用起来更加简单

3.封装可以隐藏对象的具体实现细节，阻止外部程序直接访问对象的内部状态，从而保护数据不被意外修改或破坏

访问限定符：

public修饰的成员变量，在所指定情况下均是可以正常访问的

private修饰的成员变量，只能在当前类中来使⽤

default表示什么修饰符都不加，此时只能在包当中才能被访问

protected可以在包中被访问，还可以在继承时在不同包的子类中被访问

三、static

我们以Student类为例，假设有3个学⽣，他们都是在同⼀个教室上课。

1.修饰成员变量

static-->修饰成员-->静态/类成员

(不属于某个具体的对象，是所有对象所共享的。)

static-->修饰成员变量-->静态成员变量

 class Student{
 
     private String name; 
     private int age; 

     public String classRoom = "1-101";

 }
 public class Test {
     public static void main(String[] args) {
         Student stu1 = new Student();
         Student stu2 = new Student();
         Student stu3 = new Student();
     }
 }

静态成员变量特性:

(1)不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中

(2)既可以通过对象访问，也可以通过类名访问，但⼀般更推荐使用类名访问

(3)类变量存储在方法区当中

(4)生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

可以通过：类名.静态成员变量的方式进行访问

2.static修饰成员⽅法

static-->静态成员方法，是类的方法，不是某个对象所特有的。静态成员⼀般是通过静态方法来访问的。

 public class Student{

     private static String classRoom = "Bit306";
 
     public static String getClassRoom(){
         return classRoom;
     }
 }

 public class TestStudent {
     public static void main(String[] args) {
         System.out.println(Student.getClassRoom());
     }
 }

静态方法特性：

（1）不属于某个具体的对象，是类方法

（2）可以通过对象调⽤，也可以通过类名.静态⽅法名(...)⽅式调⽤，更推荐使用后者

（3）不能在静态方法中访问任何⾮静态成员变量

（4）静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用

3.成员变量初始化

（1）就地初始化：在定义时直接给出初始值

（2）静态代码块初始化

四、代码块

1.普通代码块

定义在方法中的代码块

 public class Main{
        public static void main(String[] args) {
                { //直接使⽤{}定义，普通⽅法块
 
                        int x = 10 ;
                        System.out.println("x1 = " +x);
                }
                int x = 100 ;
                System.out.println("x2 = " +x);
        }

2.构造（实例）代码块

定义在类中的代码块(不加修饰符)，⼀般用于初始化实例成员变量。

public class Student{
    //实例成员变量
 
    private String name;
    private String gender;
    private  int age;
    private double score;
    public Student() {
        System.out.println("I am Student init()!");
    }

    //实例代码块 
    {
        this.name = "bit";
        this.age = 12;
        this.sex = "man";
        System.out.println("I am instance init()!");
     }
 
     public void show(){
        System.out.println("name: "+name+" age: "+age+" sex: "+sex);
     }
 }

 public class Main {
     public static void main(String[] args) {
         Student stu = new Student();
         stu.show();
     }
 }

3.静态代码块

使用static定义的代码块称为静态代码块,⼀般用于初始化静态成员变量。

 static {
     classRoom = "bit306";
     System.out.println("I am static init()!");
 }

#注：

• 静态代码块不管生成多少个对象，其只会执⾏⼀次

• 静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的

• 如果⼀个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)

• 实例代码块只有在创建对象时才会执行

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2025-07-25，如有侵权请联系 cloudcommunity@tencent.com 删除

对象

本文分享自作者个人站点/博客前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度