public class Student{
public String name;
public String gender;
public short age;
public double score;
public void DoClass(){}
public void DoHomework(){}
public void Exam(){}
}

我们可以用类来描述一个对象，这个对象具有什么属性，具有什么样的行为

这里我们简单顶一个一个学生类，一个学生应该具有姓名，年龄等属性。

定义类的格式


class ClassName{
field; // 字段(属性) 或者 成员变量
method; // 行为 或者 成员方法
}

在定义对象时需要注意几点：

1.在一个文件中只能定义一个类

2.main方法所在的类一般要用pubilc修饰

3.public修饰的类必须和文件名相同

4.不要轻易修改public修饰的类的名字，可以通过shift+F6(默认快捷键)修改类的名字

二、类的实例化

1.什么是实例化

我们在JAVA中定义了一个类，就相当于在计算机中自定义了一个新的类型，和int double等类似，当我们要使用类时必须通过类的实例化来使用，用类类型创建对象的过程，叫做类的实例化。

2.实例化例子



class Dog{
    public String name;  //狗的名字u
    public int age;   //狗的年龄

    public void eat(){   //狗的吃饭行为
        System.out.println("吃饭");
    }
    public void barks(){  //狗叫行为
        System.out.println("汪汪叫");
    }
}

public class Test {
    public static void main(String[] args) {
        Dog dog=new Dog();  //实例化对象
        Dog dog1=new Dog();  //再创建另外一只狗
        dog.name="小凯";  //狗的名字初始化为小凯
        dog.age=11;    //狗的年龄初始化为11
        dog1.name="小张";
        dog1.age=18;
    }
}

我们可以通过new关键字来实例化对象，通过.操作符来访问我们对象中的属性。

需要注意：

1.new关键字用于创建一个对象的实例

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

3.同一个对象可以创建多个实例 //意思就是说我们可以创建多个狗，每个狗的属性都不同，他们是单独存储的。

三、类和对象的特性

1.类是一个模型，用来描述一个实体的各种属性。

2.类的一种自定义的类型，可以用来定义一个变量。

3.一个类可以实例化多个对象，实例出来的对象是占用物理空间的，是有实际的存储。

4.类就相当于一张设计图，我们可以根据设计图来作出一个实际的东西，做出来的东西就是实例化了这个对象。

四、this引用

举个例子：

class Date{
    public int year;
    public int month;
    public int day;
    
    public void setDay(int year,int month,int day){
        year=year;
        month=month;
        day=day;
    }
    public void print(){
        System.out.println(year+"/"+month+"/"+day);
    }
}

public class Test {
    public static void main(String[] args) {
        Date date=new Date();
        date.setDay(2022,11,13);
        date.print();
    }
}

输出结果

我们给Date传参初始化，但是为什么结果全都是0呢？

仔细观察我们可以发现，year=year; month=month; day=day;这里赋值都是一样的名字，我们通过代码可以看出来我们是想让我们输入的年月日赋值给对象的年月日，但是编译器这时候就傻了，你到底是左边的是你输入的还是右边的是你输入的？到底是谁赋值给谁？

这样我们就需要用到this引用了

什么是this引用？

this 引用指向当前对象 ( 成员方法运行时调用该成员方法的对象 ) ，在成员方法中所有成员变量的操作，都是通过该 引用去访问 。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

什么意思呢？其实很简单。

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

this引用，代指的其实就是你当前类的名字，我们知道我们需要用类名.来调用对象的属性和行为，

我们创建多个对象，每个对象的名字都是不一样的，他们使用这个行为的时候自然每个名字都会不一样，所有有了this引用，你这个对象当前是什么名字，this引用指向的就是你这个对象的引用。

这样来使用就不会出问题拉。

this引用的三个作用

1.this指针作用 this 引用指向当前对象 ( 成员方法运行时调用该成员方法的对象 ) ，在成员方法中所有成员变量的操作，都是通过该 引用去访问 。

2.调用在当前类的其他构造函数，可以自己根据参数不同调用，注意必须放在构造方法的第一句，并且只能在构造函数中使用，不能来回this调用，形成环

3.访问成员方法，在方法中使用this来访问成员中的其他方法，注意不能访问静态方法和属性

this引用的特性

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

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

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

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

五、对象的构造及初始化

如何初始化对象

在JAVA中，定义一个局部变量，必须对其进行初始化，否则编译器就会报错

public static void main(String[] args) {
int a;
System.out.println(a);
}

但是对于对象来说，如果我们不给其一个初始值，也不会有任何问题

这是因为，如果我们不对对象初始化，编译器会自动给其赋值，String类型赋值为null，int short 等数字类型赋值为0，char类型赋值为'\u0000' boolean默认为false 浮点型赋值为0.0f或者0.0。

构造方法

我们对对象进行初始化，可以自己写一个方法对对象进行赋值，但是如果有很多个类，我们每次都要自己写一个方法来初始化，非常的麻烦，JAVA给我们一个非常方便的：构造方法

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

class Dog{
    public String name;  //狗的名字u
    public int age;   //狗的年龄

//    public Dog(){   //如果不写构造方法，编译器会自动生成一个这样无参的构造方法
//        
//    }
    public void eat(){   //狗的吃饭行为
        System.out.println("吃饭");
    }
    public void barks(){  //狗叫行为
        System.out.println("汪汪叫");
    }
}

如果我们自己写一个构造方法，就可以在

Dog dog=new Dog();这句语句执行的时候对对象进行初始化了。

class Dog{
    public String name;  //狗的名字u
    public int age;   //狗的年龄

  public Dog(String name){//构造方法是可以重载的，根据初始化的数据不同选择不同的构造方法
        this.name=name;
    }
    public  Dog(String name,int age){  //自己写构造函数，在实例化的时候就可以完成赋值
        this.name=name;
        this.age=age;
    }
//    public Dog(){   //如果不写构造方法，编译器会自动生成一个这样无参的构造方法
//
//    }
    public void eat(){   //狗的吃饭行为
        System.out.println("吃饭");
    }
    public void barks(){  //狗叫行为
        System.out.println("汪汪叫");
    }
}
 public static void main(String[] args) {
        Dog dog=new Dog("小凯",16);  //如果这里只写一个小凯，则会执行一个参数的构造方法
//        Dog dog=new Dog("小凯");
        System.out.println(dog.name);
        System.out.println(dog.age);
        
    }
}

构造方法的特性

1. 名字必须与类名相同

2. 没有返回值类型，设置为 void 也不行

3. 创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次

4. 构造方法可以重载 ( 用户根据自己的需求提供不同参数的构造方法 )

我们可以通过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;
}
}

六、封装

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

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

访问限定符

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

public：可以在不同包，不同类中使用

default: 可以在同一包的不同类使用（什么都不加为默认权限）,只能在当前包使用

private：只能在自己的同一包的同一类使用。

protected ：主要是用在继承中，可以在不同包中的继承的子类中使用

封装扩展之包

包的概念

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

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

导入包中的类

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

可以使用java.util.Date 导入 java.util 这个包中的 Date 类

这种方法代码比较长还不好记，我们可以使用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.* ,这样你引用谁，*就会替换为谁，但并不是将这个包里所有的方法导入，JAVA里是随用随取。 //但是这样有时会出现错误，如果两个包里面都存在同名的方法就会报错，此时只能使用第一种方法来解决

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

import java.util.*;
import java.sql.*;
public class Test {
public static void main(String[] args) {
// util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
Date date = new Date();
System.out.println(date.getTime());
}
}

可以使用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);
}
}

总结

讲解了类和对象的基本内容，涉及很多知识点，需要多多注意一些特殊情况，篇幅较长需要分两部分来写，这一篇就先到这里，感谢各位老铁。

本文含有隐藏内容，请开通VIP 后查看

JAVA类和对象（上）

类和对象的概念

一、简单定义一个类