一，对于面向对象的认识

Java是一门面向对象的语言，一切都可以称为对象。将一个大象装进冰箱，甭管步骤多复杂，大象便是对象；将牛奶放进冰箱，牛奶便是对象；你我均是对像。

再比如洗一个衣服：需要有的对象是洗衣粉，洗衣机，衣服，这三样是不可少的实体，是对象。

至于洗衣服的过程，有漂洗，脱水等等，这些都不是对象。

洗衣粉，洗衣机，衣服都是以面向对象的方式来进行处理。具体的洗衣服的过程用户不需要去关心。

二，什么是类

类是对一个对象的描述，主要用来描述对象有哪些属性，哪些功能；

比如：洗衣机

属性：品牌，颜色，尺寸等

功能：；洗衣，烘干，定时

如何用java语言来对类进行定义？

//创建类
class ClassName{
    field   //成员变量
    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中定义了一个类，相当于在计算机中定义了一个新的类型，与int，double相似。

只不过类是你自定义的类型。

用类的类型创建一个对象的过程就叫类的实例化，在java中用new关键字来实例化对象。

class PetDog {
    //狗的属性
    public String name;
    public String color;

    //狗的行为
    public void bark() {
        System.out.println("狗吠");
    }
}
public class test {
    public static void main(String[] args) {
        PetDog dog = new PetDog(); //通过new实例化对象
        dog.color = "黄色";
        dog.name = "小灰灰";
    }
}

public void bark函数在类中叫成员方法，

注意：new关键字用来创建一个实例化对象；

           使用.访问对象中的属性和方法；

            用一个类可以创建多个实例；

四，this的引用

this引用指向当前对象（成员方法运行时调用成员方法的对象），在成员方法中所有成员变量的操作都是通过this去引用。

打印结果是这样，相当于在13行中，仅仅是形参给形参赋值，

但是如果在13行这样改写

this.year = year;

this.month = month;

this.day = day;

这样结果就能成功了，因为this表示对于对象的引用，在成员方法的第一个参数就是this，它表示所指向的对象，this.year表示该对象的year，这样可以区别形参

this引用的特性：

1.this类型：对应类类型引用，即哪个对象调用就是哪个对象的应用类型

2.this只能在成员方法中使用

3.在成员方法中，this只能引用当前对象，不能再引用其他对象

4.this是成员方法第一个隐藏参数，编译器会自动传递，在成员方法执行时，编译器会将调用成员方法对象的应用传递给该成员方法，this负责接收。

五，对象构造及初始化

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

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

举例：

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

    //无参构造方法
    public Dts(){
        this.year=19;
        this.month = 32;
        this.day=12;
    }
    //三个参数的构造方法
    public Dts(int year,int month,int day){
        this.year = year;
        this.month=month;
        this.day=day;
    }
    public void print(){
        System.out.println(this.year+" "+this.month+" "+this.day);
    }
}

这两个方法名字相同构成了，方法的重载

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

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

在java中局部变量必须初始化，但是成员变量不用，系统会默认初始化；

六，封装

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

面对对象程序的三大特性：封装，继承，多态。类与对象阶段主要讲的是封装特性

何为封装，简单来说就是套壳屏蔽细节。

1.访问限定符

java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，

访问权限用来控制方法或者字段能否在类外使用，而java中提供了四种访问限定符，

说白了就是控制一个成员变量或者成员方法能否在外界使用。

画对号的就是被修饰的成员变量或成员方法可以使用的范围.

一般成员变量要用private修饰，成员方法用public修饰

2.那么什么是包呢？

为了更好的管理，把多个类收集在一起成为一组，成为软件包。就像更好的管理电脑中的文档，将它们分布在不同的文件夹里。

java中引入包，包是对类，接口等封装机制的体现，是一种对类或者接口等很好的组织方式。

一个工程中可以出现相同名称的类，只要他们在不同的包中即可。

B，D属于Test.java包中不同的类；

3.导入包中的类

java中给我们提供了很多包为我们使用，可以使用java.util.Date导入java.util这个包中的Date类

public class Testing {
    //1.手动导入
    public static void main1(String[] args) {
        java.util.Date date = new java.util.Date();
        //得到一个毫秒级的时间戳
        System.out.println(date.getTime());
    }
    //2.使用import语句导入包
    //在顶部出现import java.util.Date;
    public static void main(String[] args) {
        Date data = new Date();
        System.out.println(data.getTime());
    }
}

七，static成员

static修饰成员变量：

1.修饰的成员变量成为类变量，不属于某个具体对象，是所有对象所共享的.

2.既可以通过对象访问，也可以通过类名访问，但是推荐通过类名访问

3.类变量储存在方法区

4.类变量生命周期伴随类的一生，随类的加载而创建，随类的卸载而销毁。

5.再进行代码调试的时候，被static修饰的某个成员变量已经不再属于具体的对象

static修饰成员方法：

public class Student{
    private String name;
    private String gender;
    private int age;
    private double score;
    private static String classRoom = "Bit306";
    // ...
}
public class TestStudent {
    public static void main(String[] args) {
    System.out.println(Student.classRoom);
    }
} 

//编译失败：
Error:(10, 35) java: classRoom 在 extend01.Student 中是 private 访问控制

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

静态方法特点：

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

2.既可以通过对象访问，也可以通过类名访问，但是推荐通过类名访问

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