JavaSE类和对象

1.面向对象

1.1面向对象的过程

2.类的定义和使用

2.1定义

2.2使用

2.2.1实例化

2.2.2访问类中数据

2.3类和对象说明

3.this引用

4.对象的构造及初始化

4.1初始化对象

4.2构造方法

4.2.1特性

4.3默认初始化

4.4就地初始化

5.封装

5.1概念

编辑 5.2访问限定符

5.3private实现封装

5.4包

5.4.1概念

5.4.2导入包中的类

5.4.3自定义包

5.4.4常见的包

6.static成员类

6.1static修饰成员变量

6.2static修饰成员方法

6.3成员变量的初始化

7.代码块

7.1普通块

7.2构造代码块

7.3静态代码块

7.4执行顺序

1.面向对象

Java是一门纯面向对象的语言(Object Oriented Program，简称OOP)，在面向对象的世界里，一切皆为对象。面向对象是解决问题的一种思想，主要依靠对象之间的交互完成一件事情。

1.1面向对象的过程

传统洗衣过程（面向结果）

传统的方式：注重的是洗衣服的过程，少了一个环节可能都不行。

而且不同衣服洗的方式，时间长度，拧干方式都不同，处理起来就比较麻烦。如果将来要洗鞋子，那就是另一种放方式。按照该种方式来写代码，将来扩展或者维护起来会比较麻烦。

现代洗衣过程（面向对象）

以面向对象方式来进行处理，就不关注洗衣服的过程，具体洗衣机是怎么来洗衣服，如何来甩干的，用户不用去关心，只需要将衣服放进洗衣机，倒入洗衣粉，启动开关即可，通过对象之间的交互来完成的。

注意：面向过程和面相对象并不是一门语言，而是解决问题的方法，没有那个好坏之分，都有其专门的应用场景。

2.类的定义和使用

2.1定义

面相对象程序设计关注的是对象，而对象是现实生活中的实体，比如：洗衣机。但是洗衣机计算机并不认识，需要开发人员告诉给计算机什么是洗衣机。

上图左侧就是对洗衣机简单的描述，该过程称为对洗衣机对象(实体)进行抽象(对一个复杂事物的重新认知)，但是这些简化的抽象结果计算机也不能识别，开发人员可以采用某种面相对象的编程语言来进行描述，比如：Java语言。

类是用来对一个实体(对象)来进行描述的

主要描述该实体(对象)具有哪些属性(外观尺寸等)，哪些功能(用来干啥)，描述完成后计算机就可以识别了。

比如：洗衣机，它是一个品牌，在Java中可以将其看成是一个类别。属性：产品品牌，型号，产品重量，外观尺寸，颜色... 功能：洗衣，烘干、定时....

定义格式：

/ 创建类
class ClassName{  
    ﬁeld;       // 字段(属性) 或者 成员变量
    method;      // 行为 或者 成员方法
}

//class为定义类的关键字，ClassName为类的名字，{}中为类的主体。

类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成员属性或者类成员变量。

方法主要说明类具有哪些功能，称为类的成员方法。

class WashMachine{
    public String brand;   // 品牌
    public String type;    // 型号
    public double weight;  // 重量
    public double length;  // 长
    public double width;  // 宽
    public double height;  // 高
    public String color;   // 颜色
    
    //以上称为类的成员属性或者类成员变量

    public void washClothes(){   // 洗衣服
        System.out.println("洗衣功能");
   }
    
    public void dryClothes(){    // 脱水
        System.out.println("脱水功能");
   }
    
    public void setTime(){       // 定时
        System.out.println("定时功能");

    //以上称为类的成员方法。
   }
}

方法出了作用域就会失效

采用Java语言将洗衣机类在计算机中定义完成，经过javac编译之后形成.class文件，在JVM的基础上计算机就可以识别了。

注意事项：

类名注意采用大驼峰定义
成员前写法统一为public，后面会详细解释
此处写的方法不带 static 关键字. 后面会详细解释

class PetDog {
    public String name;//名字
    public String color;//颜色
 
    // 狗的属性
    public void barks() {
        System.out.println(name + ": 旺旺旺~~~");
   }
    
    // 狗的行为
    public void wag() {
        System.out.println(name + ": 摇尾巴~~~");
   }
}

注意事项：

一般一个文件当中只定义一个类
main方法所在的类一般要使用public修饰(注意：Eclipse默认会在public修饰的类中找main方法)
public修饰的类必须要和文件名相同
不要轻易去修改public修饰的类的名称

2.2使用

2.2.1实例化

定义了一个类，就相当于在计算机中定义了一种新的类型

用类类型创建对象的过程，称为类的实例化，在java中采用new关键字，配合类名来实例化对象。

public class Test{
 public static void main(String[] args) {
        Washmachine wanshmachine1 = new Washmachine();     //通过new实例化对象
        Washmachine wanshmachine1 = new Washmachine();
}

一个类可以创建多个实例化对象

2.2.2访问类中数据

public class Main{
 public static void main(String[] args) {
        PetDog dogh = new PetDog();     //通过new实例化对象
        dogh.name = "阿黄";
        dogh.color = "黑黄";
        dogh.barks();
        dogh.wag();
        
        PetDog dogs = new PetDog();
        dogs.name = "阿黄";
        dogs.color = "黑黄";
        dogs.barks();
        dogs.wag();
 }
}

注意事项

new 关键字用于创建一个对象的实例.
使用 . 来访问对象中的属性和方法.
同一个类可以创建多个实例.

2.3类和对象说明

类只是一个模型一样的东西，用来对一个实体进行描述，限定了类有哪些成员.
类是一种自定义的类型，可以用来定义变量.
一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量
做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

3.this引用

this 代表当前对象的引用,可以借助 this 来访问对象的字段和方法.

public class Date {
    public int year;
    public int month;
    public int day;

    public void setDay(int y,int m,int d) {
        year = y;
        month = m;
        day = d;
    }
    public void printDate() {
        System.out.println(year + "年 " + month + "月 " + day + "日");
    }

    public static void main(String[] args) {
        Date d1 = new Date();
        Date d2 = new Date();
        Date d3 = new Date();

        d1.setDay(2022,3,2);
        d2.setDay(2023,4,2);
        d3.setDay(2024,5,2);

        d1.printDate();
        d2.printDate();
        d3.printDate();
    }
}

注意事项：

1. 形参名不小心与成员变量名相同

public void setDay(int year, int month, int day){
    year = year;
    month = month;
    day = day;
}

那函数体中到底是谁给谁赋值？成员变量给成员变量？参数给参数？参数给成员变量？成员变量参数？

2. 三个对象都在调用setDate和printDate函数，但是这两个函数中没有任何有关对象的说明，setDate和 printDate函数如何知道打印的是那个对象的数据呢？

所有成员变量均通过this关键字来访问

注意事项：

this的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型
this只能在"成员方法"中使用
在"成员方法"中，this只能引用当前对象，不能再引用其他对象
this是“成员方法”第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法对象的引用传递给该成员方法，this负责来接收

规范后的代码

public class Date {
    public int year;
    public int month;
    public int day;

    public void setDay(Date this,int y,int m,int d) {
        this.year = y;
        this.month = m;
        this.day = d;
    }
    public void printDate() {
        System.out.println(this.year + "年 " + this.month + "月 " + this.day + "日");
    }

    public static void main(String[] args) {
        Date d1 = new Date();
        d1.setDay(2022,3,2);
        d1.printDate();


        Date d2 = new Date();
        d2.setDay(2023,4,2);
        d2.printDate();
    }
}

4.对象的构造及初始化

4.1初始化对象

//以下代码不会正常编译，无法正确初始化
public static void main(String[] args) {
    Date d = new Date();
    d.printDate();
    d.setDate(2021,6,9);
}


//以下代码可以正常编译
public static void main(String[] args) {
    Date d = new Date();
    d.setDate(2021,6,9);
    d.printDate();
}


//要先进行初始化再打印

1. 每次对象创建好后调用SetDate方法设置具体日期，比较麻烦，那对象该如何初始化？

2. 局部变量必须要初始化才能使用，为什么字段声明之后没有给值依然可以使用？

4.2构造方法

构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。

public class Date {
    public int year;
    public int month;
    public int day;
 
    // 构造方法：
    // 名字与类名相同，没有返回值类型，设置为void也不行
    // 一般情况下使用public修饰
    // 在创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
    public Date(int year, int month, int day){
        this.year = year;
        this.month = month;
        this.day = day;
        System.out.println("Date(int,int,int)方法被调用了");
   }
 
    public void printDate(){
        System.out.println(year + "年 " + month + "月 " + day + "日");
   }
 
    public static void main(String[] args) {
        // 此处创建了一个Date类型的对象，并没有显式调用构造方法
        Date d = new Date(2022,3,2);   // 输出Date(int,int,int)方法被调用了
        d.printDate();    
   }
}

注意：

构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。

4.2.1特性

构造方法没有返回值，且方法名和类名相同

构造方法是用来实例化对象的

名字必须与类名相同
没有返回值类型，设置为void也不行
创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次(相当于人的出生，每个人只能出生一次)
构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)

public class Date {
    public int year;
    public int month;
    public int day;
    
    // 无参构造方法
    public Date(){
        this.year = 1900;
        this.month = 1;
        this.day = 1;
   }
// 带有三个参数的构造方法
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
   }
 
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
   }
 
    public static void main(String[] args) {
        Date d = new Date();
        d.printDate();
   }
}

上述两个构造方法：名字相同，参数列表不同，因此构成了方法重载。

5. 如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的。

public class Date {
    public int year;
    public int month;
    public int day;
 
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
   }
 
    public static void main(String[] args) {
        Date d = new Date();
        d.printDate();
   }
}

上述Date类中，没有定义任何构造方法，编译器会默认生成一个不带参数的构造方法。

注意：

一旦用户定义，编译器则不再生成。

public class Date {
    public int year;
    public int month;
    public int day;
 
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
   }
    public void printDate(){
        System.out.println(year + "-" + month + "-" + day);
   }
 
    public static void main(String[] args) {
        // 如果编译器会生成，则生成的构造方法一定是无参的
        // 则此处创建对象是可以通过编译的
        // 但实际情况是：编译期报错
        Date d = new Date();
        d.printDate();
   }
}
 
/*
Error:(26, 18) java: 无法将类 extend01.Date中的构造器 Date应用到给定类型;
  需要: int,int,int
  找到: 没有参数
  原因: 实际参数列表和形式参数列表长度不同
*/

6. 构造方法中，可以通过this调用其他构造方法来简化代码

public class Date {
    public int year;
    public int month;
    public int day;
    
    // 无参构造方法--内部给各个成员赋值初始值，该部分功能与三个参数的构造方法重复
    // 此处可以在无参构造方法中通过this调用带有三个参数的构造方法
    // 但是this(1900,1,1);必须是构造方法中第一条语句
    public Date(){
        //System.out.println(year);   注释取消掉，编译会失败
        this(1900, 1, 1);
        
        //this.year = 1900;
        //this.month = 1;
        //this.day = 1;
   }
 
    // 带有三个参数的构造方法
    public Date(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
   }
}

public class Dog {
    public String name;
    public int age;
    public String color;

    public Dog(){
        this("大黄",9,"黄色");
        System.out.println("不带参数的构造方法！");
    }

    public Dog(String name, int age, String color) {
        //this(); error
        this.name = name;
        this.age = age;
        this.color = color;
        System.out.println(" Dog(String name, int age, String color) ");
    }

    public void show() {
        System.out.println("姓名："+this.name+" 年龄："+this.age+" 颜色："+this.color);
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.show();

    }
}

注意：

this(...)必须是构造方法中第一条语句

不能形成环

public Date(){
   this(1900,1,1);
}
 
public Date(int year, int month, int day) {
   this();
}
 
/*
无参构造器调用三个参数的构造器，而三个参数构造器有调用无参的构造器，形成构造器的递归调用
编译报错：Error:(19, 12) java: 递归构造器调用
*/

4.3默认初始化

为什么局部变量在使用时必须要初始化，而成员变量可以不用呢？

public class Date {
    public int year;
    public int month;
    public int day;
 
    public Date(int year, int month, int day) {
        // 成员变量在定义时，并没有给初始值, 为什么就可以使用呢？
        System.out.println(this.year);
        System.out.println(this.month);
        System.out.println(this.day);
   }
    
    public static void main(String[] args) {
        // int a;
        // System.out.println(a);

        // 此处a没有初始化，编译时报错：
        // Error:(24, 28) java: 可能尚未初始化变量a

        Date d = new Date(2021,6,9);
   }
}

具体原因还需要我们更加深入的学习来逐步了解

4.4就地初始化

在声明成员变量时，就直接给出了初始值。

public class Date {
    public int year = 1900;
    public int month = 1;
    public int day = 1;
 
    public Date(){
   }
 
    public Date(int year, int month, int day) {
   }
 
    public static void main(String[] args) {
        Date d1 = new Date(2021,6,9);
        Date d2 = new Date();
   }
}

注意：

代码编译完成后，编译器会将所有给成员初始化的这些语句添加到各个构造函数中

5.封装

5.1概念

面向对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性。何为封装呢？简单来说就是套壳屏蔽细节。

5.2访问限定符

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

public：可以理解为一个人的外貌特征，谁都可以看得到
default: 对于自己家族中(同一个包中)不是什么秘密，对于其他人来说就是隐私了
private：只有自己知道，其他人都不知道

public谁都可以访问
protected主要是用在继承中
default权限指：什么都不写时的默认权限
访问权限除了可以限定类中成员的可见性，也可以控制类的可见性

5.3private实现封装

public class Dog {
    private String name = "大黄";
    private int age = 5;
    private String color = "黄";
    
    //此时被private修饰的成员变量只能在当前Dog类下使用    

    public void show() {

        System.out.println("姓名："+this.name+" 年龄："+this.age+" 颜色："+this.color);
    }

    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.show();
    }
}

此时字段已经使用 private 来修饰. 类的调用者(main方法中)不能直接使用. 而需要借助 show 方法.

private 不光能修饰字段, 也能修饰方法

通常情况下我们会把字段（成员变量）设为 private 属性, 但是方法是否需要设为 public, 就需要视具体情形而定. 一般我们希望一个类只提供 “必要的” public 方法, 而不应该是把所有的方法都无脑设为 public.

5.4包

5.4.1概念

为了更好的管理类，把多个类收集在一起成为一组，称为软件包

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

5.4.2导入包中的类

例如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 static导入包中静态的方法和字段。

import static java.lang.Math.*;
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);
 }
}

5.4.3自定义包

在文件的最上方加上一个 package 语句指定该代码在哪个包中.
包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.bit.demo1 ).
包名要和代码路径相匹配. 例如创建 com.baidu.www 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储代码.
如果一个类没有 package 语句, 则该类被放到一个默认包中.

5.4.4常见的包

1. java.lang:系统常用基础类(String、Object),此包从JDK1.1后自动导入。

2. java.lang.reﬂect:java 反射编程包;

3. java.net:进行网络编程开发包。

4. java.sql:进行数据库开发的支持包。

5. java.util:是java提供的工具程序包。(集合类等) 非常重要

6. java.io:I/O编程开发包。

6.static成员类

public class Student{
    // ...
    public static void main(String[] args) {
        Student s1 = new Student("张三", "男", "112");
        Student s2 = new Student("李四", "女", "112");
        Student s3 = new Student("王五", "男", "112");
   }
}

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

6.1static修饰成员变量

static修饰的成员变量，称为静态成员变量

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

静态成员变量特性：

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

public class Student{
    public String name;
    public String sex;
    public static String classRoom = "Bit306";
    
    // ...
    
    public static void main(String[] args) {
        // 静态成员变量可以直接通过类名访问
        System.out.println(Student.classRoom);
 
        Student s1 = new Student("张三", "男", "112");
        Student s2 = new Student("李四", "女", "112");
        Student s3 = new Student("王五", "男", "112");
 
        // 也可以通过对象访问：但是classRoom是三个对象共享的
        System.out.println(s1.classRoom);
        System.out.println(s2.classRoom);
        System.out.println(s3.classRoom);
   }
}

6.2static修饰成员方法

一般类中的数据成员都设置为private，而成员方法设置为public，那设置之后，Student类中classRoom属性如何在类外访问呢？

被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的。

public class Student{
    // ...
    
    private static String classRoom = "Bit306";
    
    // ...
    
    public static String getClassRoom(){
        return classRoom;
   }
}
 
public class TestStudent {
    public static void main(String[] args) {
        System.out.println(Student.getClassRoom());
   }
}

静态方法特性

不属于某个具体的对象，是类方法
可以通过对象调用，也可以通过类名.静态方法名(...)方式调用，更推荐使用后者
不能在静态方法中访问任何非静态成员变量

public static String getClassRoom(){
    System.out.println(this);
    return classRoom;
}
 
// 编译失败：Error:(35, 28) java: 无法从静态上下文中引用非静态 变量 this
 
public static String getClassRoom(){
    age += 1;
    return classRoom;
}
 
// 编译失败：Error:(35, 9) java: 无法从静态上下文中引用非静态 变量 age

4. 静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用，非静态可以调用静态

public static String getClassRoom(){
    doClass();
    return classRoom;
}
 
// 编译报错：Error:(35, 9) java: 无法从静态上下文中引用非静态 方法 doClass()

6.3成员变量的初始化

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

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

1. 就地初始化

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

2. 静态代码块初始化

7.代码块

使用 {} 定义的一段代码称为代码块。

根据代码块定义的位置以及关键字，又可分为以下四种：

1.普通代码块
2.构造块
3.静态块
4.同步代码块（后续讲解多线程部分再谈）

7.1普通块

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);
 }
}

7.2构造代码块

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

定义在类中，与成员变量和成员方法为同一级

7.3静态代码块

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

注意事项

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

7.4执行顺序

实例代码块优先于构造代码块执行

class Student {

    int age;

    {
        System.out.println("这是实例化代码块");
    }
    
    public Student (){
        this.age = age;
        System.out.println("不带参数的构造方法");
    }

//    {
//        System.out.println("这是实例化代码块");
//    }

}

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
    }
}

实例成员变量和构造块有先后顺序

class Student {
    private String name = "abc";
    int age;

    {
        this.name = "zsj";
        System.out.println("这是实例化代码块");
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    //    {
//        System.out.println("这是实例化代码块");
//    }

}

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student.getName());
    }
}

静态、实例代码块一起运行时的顺序

class Student {
    int age;
    public Student() {
        System.out.println("这是构造方法");
    }

    {
        System.out.println("这位是实例化代码块");
    }
    static {
        System.out.println("这是静态代码块2");
    }
    static {
        System.out.println("这是静态代码块1");
    }
}

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
    }
}