JAVA封装

发布于：2022-12-18 ⋅ 阅读:(160) ⋅ 点赞:(0)

目录

一、封装

二、static成员

static成员变量初始化

就地初始化

静态代码块初始化

三、内部类

四、重写

一、封装

理解

对内部细节 进行封装，对外只是提供了一些公开的接口 对 类 内部的实现细节 进行隐藏/封装 对外 只提供一些公开的接口 供其他用户进行访问

权限—>访问修饰限定符来进行修改

 

内容

包：只同一个文件夹下

public：共有的，可被调用的

default: 对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了

private：只有自己知道，其他人都不知道

代码

class Person{
    private String name;//私有的属性
    public int age;//公开的属性

    public void setName(String name){ //可用公开的方法改变私有的属性
        this.name=name;
    }
    public String getName(){
        return this.name;
    }
    public void show(){
        System.out.println("姓名："+name+" 年龄："+age);
    }
}

public class FZ {
    public static void main(String[] args) {
        Person person = new Person();
        //person.name = "xiao";会报错，因为他是私有的属性无法调用
        person.setName("bit");
        System.out.println(person.getName());

    }
}

二、static成员

理解

static修饰成员变量

static修饰的成员变量，称为静态成员变量，静态成员变量最大的特性：不属于某个具体的对象，是所有对象所共享的

  • 静态成员变量特性
    1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
    2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐 访问方式 通过类名
    3. 静态的，不依赖于对象
    4. 在静态方法内部，不能直接访问非静态的数据成员和成员方式
    5. 类变量存储在方法区当中
    6. 生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

内容

可以说，在属性前public后加上stactic后在被new新对象的时候不会改变这个属性，他已经是类共有的啦

    public class Student{
        private String name;
        private String gender;
        private int age;
        private double score;
        private static String classRoom = "Bit306";
// ...
    }

static成员变量初始化

  1. 就地初始化

    就地初始化指的是：在定义时直接给出初始值

  2. 静态代码块初始化

    运用代码块

    普通代码块 ：定义在方法中的代码块

    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);
    }
}
// 执行结果
x1 = 10
x2 = 100

    构造块 ：定义在类中的代码块(不加修饰符)。也叫：实例代码块。构造代码块一般用于初始化实例成员变量

    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();
    }
} 
// 运行结果
        I am instance init()!
        I am Student init()!
        name: bit age: 12 sex: man

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

    public class Student{
    private String name;
    private String gender;
    private int age;
    private double score;
    private static String classRoom;
    //实例代码块
    {
        this.name = "bit";
        this.age = 12;

        this.gender = "man";
        System.out.println("I am instance init()!");
    } 
    // 静态代码块
    static {
        classRoom = "bit306";
        System.out.println("I am static init()!");
    }
    public Student(){
        System.out.println("I am Student init()!");
    }
    public static void main(String[] args) {
        Student s1 = new Student();
        Student s2 = new Student();
    }
}

    同步代码块

**注意事项 **

  • 静态代码块不管生成多少个对象，其只会执行一次
  • 静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
  • 如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行(合并)
  • 实例代码块只有在创建对象时才会执行
  • 代码块运行顺序 1.静态 2.普通 3.无参构造

三、内部类

理解

类中再定义一个类 多用与链表中的节点

可以联系C语言中链表结构去思考：一个函数中引用一个节点结构

内容

 

  • 1、如何获取 实例内部类的对象

    OuterClass.InnerClass innerClass =outerClass.new InnerClass();

  • 2、实例内部类中 不能有静态的成员变量 （先静态后构造），如果非要定义，那么只能被static final 修饰

  • 3、在实例内部类当中，如何访问外部类里相同的成员变量？

    在实例内部类当中 获取外部类的OuterClass.this.data1

代码

package inner;


class OuterClass{
    public int data1 = 1;
    int data2 = 2;
    public static int data3 = 3;

    public void test(){
        System.out.println("OuterClass::test()");
    }
    /**
     *   实例内部类
     *   1、如何获取 实例内部类的对象
     *               OuterClass.InnerClass innerClass =outerClass.new InnerClass();
     *   2、实例内部类中 不能有静态的成员变量 （先静态后构造），如果非要定义，那么只能被static final 修饰
     *   3、在实例内部类当中，如何访问外部类里相同的成员变量？
     *               在实例内部类当中 获取外部类的OuterClass.this.data1    
     */

    class InnerClass{
        public int data4 = 4;
        int data5 = 5;
        //public static int data6; //实例内部类中 不能有静态的成员变量

        public void func(){
            System.out.println("InnerClass::func()");

            System.out.println(OuterClass.this.data1);//内部引用外部的类

            System.out.println(data1);
            System.out.println(data2);
            System.out.println(data3);
            System.out.println(data4);
            System.out.println(data5);

        }
    }


}

public class Test {
    public static void main(String[] args) {
        //外部类的引用对象
        OuterClass outerClass = new OuterClass();
        System.out.println(outerClass.data1);

        OuterClass.InnerClass innerClass =outerClass.new InnerClass();
    }
}

四、重写

理解

对象的打印，太繁琐，需要一直调用方法后才能，我们可以直接重写（底层）代码从而实现print直接打印自己想要的

内容

 代码

package inner;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

class Person1{
    public int age = 18;
    public String name="bit";

    public void show(){
        System.out.println("姓名："+name+"年龄："+age);
    }// 被代替

    @Override // 监视对错的注解
    public String toString() {
        /*return "Person1{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';*/
        return "姓名："+name+"年龄："+age;
    }

}

public class Person {
    public static void main(String[] args) {
        Person1 person1 = new Person1();
        //person1.show;
        System.out.println(person1);
    }



}

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布