Java类和对象（2）

一、封装

1、封装的概念

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

举例说明：电脑这样的复杂设备，对于计算机使用者而言，不用关心内部核心部件，比如主板上线路是如何布局的，CPU内部是如何设计的等，用户只需要知道，怎么开机、怎么通过键盘和鼠标与计算机进行交互即可。因此计算机厂商在出厂时，在外部套上壳子，将内部实现细节隐藏起来，仅仅对外提供开关机、鼠标以及键盘插孔等，让用户可以与计算机进行交互即可。

2、访问限定符

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者成员变量能否直接在类外使用。Java中提供了四种访问限定符：private  default  protected  public

public：可以理解为一个人的外貌特征，谁都可以看得到

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

default权限指：什么都不写时的默认权限

private：只有自己知道，其他人都不知道（同一包中的同一类），即只能在当前的类中使用

protected主要是用在继承中，继承部分详细介绍

访问权限除了可以限定类中成员的可见性，也可以控制类的可见性

private使用示例

class Date {
    public int year;
    public int month;
    private int day;
    //成员变量建议是private
    //成员方法建议public
    //可以调用方法来拿到private成员和赋值
    //右键选中generate -> Getter and Setter
    public int getDay(){
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }
    //private(只有自己知道) <default (对于自己家族来说不是秘密)<protected <public(都能被看到)
}

public class test {
    public static void main(String[] args){
        Date date = new Date();
        date.setDay(12);
        System.out.println(date.getDay());
    }
}

具体讲default前先来了解一下包

3、包的概念

简单来说就是一个文件夹

在面向对象体系中，提出了一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，称为软件包

在Java中也引入了包，包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一个包中的类不想被其他包中的类使用。包还有一个重要的作用：在同一个工程中允许存在相同名称的类，只要处在不同的包中即可。

导入包import

Java 中已经提供了很多现成的类供我们使用. 例如Date类：可以使用 java.util.Date 导入 java.util 这个包中的 Date类。

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

但是这种写法比较麻烦一些, 可以使用 import语句导入包。

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

如果需要使用 java.util 中的其他类, 可以使用 import java.util.*

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

但是我们更建议显式的指定要导入的类名，否则是容易出现冲突的情况，即同时导入的不同包下有相同的类名，编译器不知道使用哪个。

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

但是不建议使用，可读性低

import static java.lang.Math.pow;
import static java.lang.Math.sqrt;

public class test {
    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);
    }
}

创建包

包名采用全是小写的方式，域名的逆置写法

如果是www.baidu.com包名就是com.baidu.www

package代表类的路径

如果一个类没有 package 语句, 则该类被放到一个默认包中src。

继续来看default

default可以在同一包中的同类使用

还可以在同一包的不同类使用

在test中访问类test2中的default权限的成员（name）

二、static成员

先来谈学生类

class Student{
    private String name;
    private String sex;
    private int age;
    public String ClassRoom;

    public Student(String name, String sex, int age,String ClassRoom) {
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.ClassRoom = ClassRoom;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

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

public class test {
    public static void main(String[] args) {
        Student student1 = new Student("张三","男",18,"3.1");
        Student student2 = new Student("李四","男",19,"3.1");
        Student student3 = new Student("王五","男",18,"3.1");
        }
}

之前在Student类中定义的成员变量，每个对象中都会包含一份(称之为实例变量)，因为需要使用这些信息来描述 具体的学生。而现在要表示学生上课的教室，这个教室的属性并不需要每个学生对象中都存储一份，而是需要让所有的学生来共享。在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对 象，是所有对象所共享的，并且存在于方法区，只有一份。  

static修饰成员方法

public static String ClassRoom = "3.1";

用static修饰ClassRoom后，就可以直接用类名访问ClassRoom，不依赖于对象，生命周期伴随类的一生

public class test {
    public static void main(String[] args) {
        Student student1 = new Student("张三","男",18);
        Student student2 = new Student("李四","男",19);
        Student student3 = new Student("王五","男",18);

        System.out.println(student1.ClassRoom);//合法但不合理
        System.out.println(Student.ClassRoom);//建议使用类名访问static成员
        
        }
}

注意：在方法中定义的变量是局部变量，而静态的变量属于类变量。java中不允许定义局部的静态变量 

用static修饰方法

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

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

3. 不能在静态方法中访问任何非静态成员变量

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

static成员变量初始化

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

2、静态代码块初始化（后续讲解）

三、代码块

1、分类

（1）普通代码块：明确作用域

（2）构造快：定义在类中的代码块(不加修饰符)，定义在成员的外面，也叫：实例代码块、非静态代码块。构造代码块一般用于初始化实例成员变量。

实例代码块的执行先于构造方法

成员变量被赋值结果与赋值顺序有关

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

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

静态代码块的执行先于实例化代码块

同样静态成员变量被赋值结果与赋值顺序有关

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

（4）同步代码块：（后续讲解多线程部分讲解）

class Student{
    private String name;
    private String sex;
    private int age;
    public static String ClassRoom = "3.1";
    
    //构造块
    {
        System.out.println("构造快、实例代码块、非静态代码块");
        this.name = "小明";
    }
    //成员变量被赋值结果与赋值顺序有关

    //静态代码块
    static{
        System.out.println("静态代码块。。。。。。。。。");
        ClassRoom = "3.2";
    }
    //优先被执行
    //同样成员变量被赋值结果与顺序有关
    //执行顺序：静态代码块 先于 实例化代码块 先于 构造方法
    //静态代码块只执行一次，类只会被加载一次

    public Student(){
        System.out.println("不带参数的构造方法");
    }

    public Student(String name, String sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
        System.out.println("三个参数的构造方法");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
public static void main(String[] args) {

       /* {
            //定义在方法里的 普通代码块
            //作用：明确作用域
            int a = 10;
            System.out.println(a);
            //局部代码块，a变量在代码块的外面不能使用
        }*/

        //实例化代码块
        //定义在类的里面，方法的外面，与成员变量和方法同级
        //作用：初始化非静态成员
        //只有在创建对象的时候才会被执行
        Student student = new Student("张三",10,"男");
        //会先打印实例化代码块里的，构造方法在后
        
    }

打印结果