JavaSE修炼手册（02）--封装

前言：面向对象！

Java与C一个很大的区别就是C是面向过程的语言，而Java是面向对象的

面向 "对象" 的三个特征：封装，继承，多态 

一，什么是封装

封装指的是将数据和行为封装在一个类中，通过对外提供公共的方法来访问和操作数据，同时隐藏内部的实现细节。

1.1 目的

隐藏类的实现细节，并且保护数据不被随意修改，从而增强了代码的安全性和可维护性

1.2 意义

可以隐藏类的实现细节，从而达到安全性！

二，如何封装

直接看代码 >> 

idea中 封装生成的快捷键 >>> alt + Insert

class Student {
    //成员变量：定义在方法的外部,类的内部！
    private String name;//姓名
    public int age;//年龄
    
    public String getName(){
        return this.name;
        //获取 name 的值
    }
    public void setName(String name){
        this.name = name;
        //修改 name 的值
    }
    
}
public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("xiaolin");//修改设置 name 的值
        System.out.println(student.getName());//获取 name 的值

    }
}

三，访问限定符

Java中只要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，而访问权限用来控制方法或者字段能否直接在类外使用。Java中提供了四种访问限定符

Java中的访问修饰符有：private，protected，public；当定义一个成员变量的时候，没有写这三个任意一个的时候，此时的权限是默认权限（ default ）

注意：一般情况下成员变量设置为 private，成员方法设置为 public。

四，包

4.1 导入包中的类

利用 import 语句，例如import  java.util.Date; // (util >> 包   Date >> 类)

注意：

1. import语句不能导入一个指定的包，例如 import  java.util  >> 报错！！
2. 导入  import  java.util.*  和  import  java.sql.* 这两个类包里面中都包含了 Data.java 这个类，所以会造成冲突

有时，导入合适的类，我们可以更加方便的使用Java为我们提供的一些方法

也可以使用import  static导入包中静态的方法和字段

例如：

import static java.lang.Math.*;

public class Test01 {
    public static void main(String[] args) {
        double x = 30;
        double y = 40;

        //静态导入的方式写起来更方便一些
        //double result = Math.sqrt(Math.pow(x,2) + Math.pow(y,2));
        double result = sqrt(pow(x,2) + pow(y,2));
        System.out.println(result);
    }
}

4.2 自定义包

基本规则：

• 在文件的最上方加上一个 package 语句指定该代码在哪个包中.
• 包名需要尽量指定成唯一的名字，通常会用公司的域名的颠倒形式（com.csdn.demo1）.
• 如果一个类没有 package 语句，则该类被放到一个默认包中.

 4.3 常见的包

1. java.lang：系统常用基础类( String，Object )此包从JDK1.1后自动导入,(注意：java.lang 下的类就不用 import ，但 .lang 下的包下的类就用)
2. java.lang.reflect：java 反射编程包；
3. java.net ：进行网络编程开发包；
4. java.sql：进行数据库开发的支持包；
5. java.util：是java提供的工具工程包；( 集合类等 ) 非常重要
6. java.io：I/O编程开发包
7. （以上2-6点，都要 import 导入）

五，static成员 

在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的。 

5.1 static修饰成员变量

static修饰的成员变量 -->> 静态成员变量（静态成员方法）-->> 有的书上或资料上会叫做：类变量或者类方法。

【静态成员变量特性】

1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
3. 类变量存储在方法区当中
4. 生命周期伴随类的一生（即：随类的加载而创建，随类的卸载而销毁）

 5.2 static修饰成员方法

Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是莫格对象所持有的。

【静态方法特性】

1. 不属于某个具体的对象，是类方法
2. 可以通过对象调用，也可以通过类名. 静态方法名(...)方式调用，更推荐使用后者
3. 不能在静态方法中直接访问任何非静态成员变量 -->> show()；//这样会报错！！！可以间接访问-->> Student  student = new  Student( );
4. 静态方法中不能直接调用任何非静态方法，因为非静态方法有 this 参数，在非静态方法中调用时侯无法传递this引用（static 方法里不能使用 this）
5. 静态方法无法重写，不能用来实现多态

总之：普通成员方法 就用 对象引用 去调用

           静态成员方法 就用 类名 去调用

 5.3 static成员变量初始化

注意：静态成员变量一般不会放在构造方法中来初始化，构造方法中初始化的时与对象相关的实例属性

静态成员变量的初始化分为两种：就地初始化 和 静态代码块初始化。

六，代码块

使用 {} 定义的一段代码称为代码块。根据代码块定义的位置以及关键字，又可分为一一下四种：

• 普通代码块
• 构造块
• 静态块
• 同步代码块

6.1 普通代码块（较少使用）

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

public class Test1 {
    public static void main(String[] args) {
        {
            //直接使用{}定义，普通代码块
            int x = 10;
            System.out.println("x=" +x);
        }
    }
}

 6.2 构造代码块 / 实例代码块

构造块：定义在类中的代码块(不加修饰符)。也称：实例代码块。构造代码块一般用于初始化实例成员变量。--->>>在方法的外面，类的里面。

public class Test1 {
    private String name;
    private String gender;
    private int age;
    private double score;
    
    //实例代码块
    {
        this.name = "xiaolin";
        this.age = 18;
        this.gender = "man";
        
    }
}

6.3 静态代码块 --->>> 只执行一次

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

静态代码块：只要类被加载就会被执行

实例代码块：一定是 实例化对象( new ) 的时候才被执行

【注意】 

• 静态海马快不管生成多少个对象，其只会执行一次
• 静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
• 如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行（合并）
• 实例代码块只有在创建对象时才会被执行

代码块的执行顺序：！！！！

1. 静态代码块
2. 实例代码块（构造代码块）
3. 不带参数的构造方法

七，对象的打印 

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

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

    public static void main(String[] args) {
        Person person = new Person("xiaolin","男",18);
        System.out.println(person);
    }
}



//输出结果：demo1.Person@1b6d3586

main方法中，println 在打印时会调用Object类的toString

换句话说：即 如果我们自己写了一个toString方法，则 打印时println 会自动调用toString方法

此时当我们自己类重新通过编译器实现了toString方法之后，会调用我们自己写的toString方法

如果想要默认打印对象中的属性该如何处理呢？

答：重写toString方法即可 

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

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

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", age=" + age +
                '}';
    }

    public static void main(String[] args) {
        Person person = new Person("xiaolin","男",18);
        System.out.println(person);
    }
}



//输出结果：Person{name='xiaolin', gender='男', age=18}