封装和访问修饰符

封装

目的

提高数据安全性，通过封装，可以实现对属性的访问权限控制，同时增加了程序的可维护性。它将类的状态信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。

封装的步骤

1、修改属性的可见性

将属性私有化，使用private关键字完成属性私有化，这种属性只有本类能访问。

2、设置setter/getter方法

我们一般对每一个私有属性提供公共public的setter/getter方法供外界来访问我们的私有属性。

3、设置属性的存取限制

对属性设置合法性检验，需要在setter方法中进一步利用条件判断语句进行赋值限制。

public class Person {//定义人类
    //私有化属性
    private String name;//姓名
    private  String gender;//性别
    private int age;//年龄

    //getter/setter方法封装
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getGender() {
        return gender;
    }
    //设置性别存取值只能为男或者女
    public void setGender(String gender) {
        if(gender.equals("男")||gender.equals("女")){
            this.gender = gender;
        }else{
            System.out.println("性别不合法！");
        }

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

    //构造方法初始化数据
    //无参构造
    public Person(){
        this.name = "张三";
        this.gender = "男";
        this.age = 18;
    }
    //有参构造
    public Person(String name, String gender, int age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }

    public void say(){
        System.out.println("姓名："+this.name+"性别："+this.gender+"年龄："+this.age);
    }
}


public class Test {
    //测试类中调用Person类
    public static void main(String[] args) {

        Person person = new Person();
        person.setAge(23);
        person.say();
//打印：姓名：张三性别：男年龄：23
    }
}

包

包帮助管理大型软件系统，将语义近似的类组织到包中。

包可以包含类和子包。

相当于我们在电脑上创建一个文件夹，而里面存放的是.java文件。

java中包的使用：

• package语句：作为java源文件类中的第一条语句，指明该文件中定义的类所在的包。

• 格式：package 包名；
  
  包名基本上用小写字母，可以有多个包，通过包名.子包名的形式命名

访问修饰符

类和类成员的访问控制

• 类的访问修饰符（√表示可以使用，×表示不可以使用）

  修饰符\作用域	同一包中	非同一包中
  public	√	√
  默认修饰符	√	×

• 类成员的访问修饰符（√表示可以使用，×表示不可以使用）

static关键字

​ 一个类可以被创建n个对象，如果n个对象中的某些数据需要共用，就需要使用static关键字修饰这些数据。

修饰在属性上

• 语法：static数据类型 变量名

​ 使用static修饰的属性我们认为是类的属性，不带static修饰的属性我们认为是对象的属性。

• 类属性访问

​ 第一种方式：类名.类属性（推荐使用），

​ 第二种方式：对象实例.类属性

• 应用的场景

  ​ 我们把常量一般定义成static，或者当前类创建的每一个对象都有相同的属性也可以把这种属性定义成static的

• static在属性内存中的加载流程
  

• static在属性的生命周期

对象属性生命周期：

​ 创建对象的时候初始化对象属性（没有类属性早），当当前对象变 成匿名对象时，jvm会回收该垃圾对象，对象属性随之消失。

类属性的生命周期：

​ 当Person.class被载入内存时personNum类属性就初始化了，jvm关闭 类属性就消失了

修饰在方法上

• 语法语法：

public static 返回值（void） 方法名（数据类型1 变量1，数据类型2 变量2，….）{

方法体

[return 结果]

}

static修饰在方法上就是类方法或者称为静态方法，不用static修饰的方法称为实例方法。

• 类方法的访问

第一种方式：类名.类方法() 推荐使用

第二种方式：对象实例.类方法()

注意：在静态方法中不能直接访问实例变量和实例方法

​ 在实例方法中可以直接调用类中定义的静态变量和静态方法

public class Person {//定义人类
    public String name;//姓名
    public String gender;//性别
    public static int age;//年龄
    public static void show(String name,String gender,int age){
        System.out.println("姓名："+name+"，性别："+gender+"，年龄："+age);
    }
}
public class Test {
    //测试类中调用Person类
    public static void main(String[] args) {
        Person person = new Person();
        Person.show("张三","男",23);
        //打印：姓名：张三，性别：男，年龄：23
    }
}

静态代码块

语法：class A{

​ //静态代码块

​ static{

​ }

}

1.静态代码块主要是用于初始化资源。

2.静态代码块在main之前执行。

3.静态代码块可以范围类属性（必须先定义）和类方法

public class TestStatic{
    String name;
    public void method(){

    }
    static int age;
    public static void method1(){
        System.out.println("静态方法被调用了");
    }
    //不能访问对象属性和方法
    static{
        System.out.println("静态代码块被执行了");
        System.out.println(age);
        method1();
    }
    public static void main(String[] args){
        System.out.println("主方法执行");
    }
}
//静态代码块被执行了
//0
//静态方法被调用了
//主方法执行

单例模式（了解）

​ 设计模式：一共有23种设计模式 设计模式就是有经验的前人通过实践总结下来被大家公认的代码设计思想。

​ 单例模式作用：保证一个类只有一个实例，并且提供一个访问该实例的全局访问入口

单例模式的常用

1.Windows的任务管理器

2.Windows的回收站，也是一个单例应用

实现步骤：

1. 私有化构造器

2. 定义一个类方法用于获得单例的对象，返回值是这个类的类型

3. 提供一个公有的静态方法，返回实例对象

4. 实现这个类方法

懒汉式

class Singleton{
    ////2.本类内部创建对象实例
    private static Singleton s;
    //1.构造方法私有化，外部不能new
    private Singleton(){
    }
    //懒汉
    //3.提供一个公有的静态方法，返回实例对象
    public static Singleton getInstance(){
        if(s == null){
            s = new Singleton();
        }
        return s;
    }
}

public class TestSingleton{
    public static void main(String[] args){
        Singleton s = Singleton.getInstance();
        System.out.println(s);
        Singleton s1 = Singleton.getInstance();
        System.out.println(s1);
        Singleton s2 = Singleton.getInstance();
        System.out.println(s2);
    }
    //Singleton@1540e19d
    //Singleton@1540e19d
    //Singleton@1540e19d
}

饿汉模式

//饿汉模式
class Singleton{
    private static Singleton s = new Singleton();

    private Singleton(){

    }
    //饿汉
    public static Singleton getInstance(){
        return s;
    }
}

public class TestSingleton{

    public static void main(String[] args){
        Singleton s = Singleton.getInstance();
        System.out.println(s);
        Singleton s1 = Singleton.getInstance();
        System.out.println(s1);
        Singleton s2 = Singleton.getInstance();
        System.out.println(s2);
    }
        //Singleton@1540e19d
        //Singleton@1540e19d
        //Singleton@1540e19d
}