Java基础-封装

最新推荐文章于 2022-04-11 10:55:16 发布

Tony_313726

最新推荐文章于 2022-04-11 10:55:16 发布

阅读量390

点赞数

分类专栏： Java基础

本文链接：https://blog.csdn.net/sc_942344134/article/details/104016565

版权

Java基础专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Java基础-封装

1封装的概述

1.1封装的作用

封装的作用就是有效地防止不正确、不准确的数据被录入系统,从而提高程序的安全性。

1.2如何实现封装

封装的步骤分三步:

(1)属性私有化 private;

(2)编写公有的取值赋值方法 getter/ setter方法;

(3)在赋值的方法中进行合法性验证。

【实例1】封装

public class Person {
    //1.属性私有化
    private String name;//姓名
    private Integer age;//年龄
    //2.编写公有的取值赋值方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {   
        return age;
    }
    public void setAge(Integer age) {
        if(age<0||age>120) {
            this.age=18;
        }
        else {
            this.age = age;
        }
    }
}

【实例2】测试Person类

public class PersonTest {
    @Test
    public void ageTest() {
        //调用无参构造方法创建对象
        Person person=new Person();
        //调用赋值的方法给年龄属性赋值
        person.setAge(-200);
        //调用取值的方法获取年龄的值
        System.out.println("年龄："+person.getAge());
    }
}

2 this关键字

2.1 this关键字的含义

this是一个关键字，指代当前对象，存储的是当前对象的内存地址，实例3测试输出this的值，运行效果如图所示：

【实例3】输出this

public class Person2 {

    public Person2() {
        super();
        System.out.println("this="+this);
    }
    
    public static void main(String[] args) {
        //调用无参构造方法创建对象
        Person2 person=new Person2();
        System.out.println("person="+person);
    }
}

2.2this关键字的作用

(1)可以访问本类的属性:this.属性名,this可以省略。

(2)可以调用本类的方法:this.方法名(),this可以省略。

(3)可以调用本类的构造方法:(必须是构造方法中的第一句代码)

this():调用本类的无参构造方法

this(实参值):调用本类的带参构造方法。

(4)当局部变量与成员变量名称相同时,使用this代表成员变量。解决的是局部变量名称与成员变量名称冲突的情况。

【实例4】this关键字的作用

public class Person3 {
    //1.属性私有化
    private String name;//姓名
    private Integer age;//年龄
    //2.年龄属性：公有的取值赋值的方法
    public void setName(String name) {
        this.name = name;
    }
    //无参构造方法
    public Person3() {
        super();
    }
    //1个参数构造方法
    public Person3(String name) {
        super();
        this.name = name;
    }
    //2个参数构造方法
    public Person3(String name, Integer age) {
        super();
        this.name = name;
        this.age = age;
    }
    //3.编写类的方法
    public void show() {
        System.out.println("姓名：使用this="+this.name);
        System.out.println("姓名：省略this="+name);
    }
    public void intro() {
        System.out.println("调用show方法，使用this");
        this.show();
        System.out.println("调用show方法，省略this");
        show();
    }
}

编写测试方法

//测试Person3.intro()
@Test
public void introTest() {
    //使用带2个参数的构造方法实例化对象person
    Person3 person=new Person3("Tony",20);
    //调用方法intro()
    person.intro();
}

3 static关键字

3.1 为什么需要static

为了节约存储空间，在Java中有个关键字叫 static,在成员变量前加上 static之后,这个变量称为静态变量,将从堆内存中拿出放到方法区中的静态区去存储,可以被这个类的所有对象所共享。

【实例5】静态变量

public class Person5 {
    //1.类的属性
    private String name;
    private int age;
    public static String city;//城市
    //带参的构造方法
    public Person5(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    //编写show方法
    public void show() {
        System.out.println("姓名："+name+"\t年龄："+age+"\t城市："+city);
    }
}

编写测试方法

//测试Person5类的show方法
@Test
public void showTest() {
    Person5.city="铁岭";
    //创建Person5类型的对象p1
    Person5 p1=new Person5("赵四儿", 56);
    //创建Person5类型的对象p2
    Person5 p2=new Person5("刘能二", 57);
    //调用方法
    p1.show();
    p2.show();
}

内存分析图：

主方法中的第一句 Person.city使用的是类名调用属性,在给这个属性赋值的时候并没有创建对象,所以 static修饰的属性是在创建对象之前就产生了,是在类加载到内存时就被加载到内存了。通过运行效果图可以看出,这个 static的属性在被赋了一次值之后,其他的对象都可以共享这个属性值了。

3.2 static的作用

static关键字的作用如下:

(1) static可以修饰成员变量,称为静态变量或者类变量;

(2) static可以修饰成员方法,称为静态方法或者类方法;

(3) static可以修饰代码块,称为静态代码块;

(4) static可以修饰内部类,称为静态内部类。

static修饰的方法或属性有两种调用形式

(1)类名.方法名()

类名.属性

(2)对象名.方法名()

对象名.属性

4 代码块

使用{}括起来的一段代码称为代码块根据代码块的声明位置可分为以下四类：

4.1 普通代码块

声明在方法或语句中，通常用来限定变量的作用域。

【实例6】普通代码块

/*
 * 普通代码块
 * */
public class BlockDemo {
    public static void main(String[] args) {
        //普通代码块，定义在方法中的一对{},在{}中写代码
        {
            int i=10;
            System.out.println("我是普通代码块");
        }
    }
}

4.2 构造代码块

构造代码块与构造方法都是在创建对象时才被执行的，而且构造代码块优先于构造方法先执行。

【实例7】构造代码块

/*
 * 构造代码块
 * */
public class BlockDemo2 {
    //构造方法
    public BlockDemo2() {
        super();
        System.out.println("我是构造方法.......");
    }
    //构造代码块，声明在类中
    {
        System.out.println("我是构造代码块.......");
    }
    public static void main(String[] args) {
        BlockDemo2 blockDemo2=new BlockDemo2();
    }
}

4.3 静态代码块

静态代码块在类加载到内存时，一起被加载到内存中，而且只加载一次。

/*
 * 静态代码块，执行顺序优于构造代码块
 * 只执行一次
 * */
public class BlockDemo3 {
    //构造方法
    public BlockDemo3() {
        super();
        System.out.println("我是构造方法.....");
    }
    //构造代码块
    {
        System.out.println("我是构造代码块.....");
    }
    //静态代码块
    static {
        System.out.println("我是静态代码块.....");
    }
    public static void main(String[] args) {
        BlockDemo3 bd1=new BlockDemo3();
        System.out.println();
        BlockDemo3 bd2=new BlockDemo3();
        System.out.println();
        BlockDemo3 bd3=new BlockDemo3();
        System.out.println();
    }
}