目录
一、前言
二、类与对象的介绍
1.类的定义格式
三、类的实例化
1.类的实例化介绍
2.成员初始化
3.类中方法的实现
四、封装
1.private实现封装
2.getter和setter方法
五、构造方法的使用
1.构造方法的介绍
2.构造方法的特性
六、this引用
1.this的介绍
2.this的特性
七、static静态关键字
八、总结
一、前言
大家好鸭！通过上一篇博文的学习，相信你们都了解Java中的数据类型与变量、运算符。今天蜡笔小欣带大家一起走进Java的知识世界，去认识Java中的类与对象。
二、类与对象的介绍
这里的对象可不是我们现实中的对象，当然你们也可以自己new一个对象，哈哈哈哈小欣就不再开玩笑了。在计算机中，它不能像我们人一样去理解世界上的东西，为了更好的编辑，就抽象出了类和对象。类是用来对一个实体(对象)来进行描述的，通过把这个功能放在一起，然后由一个人去调用这个类的功能，接着编写相应的功能，而这个调用者就是对象的实现者。
1.类的定义格式
在
java
中定义类时需要用到
class关键字
，具体语法如下：
//
创建类
class
ClassName
{
field
;
//
字段
(
属性
)
或者 成员变量
method
;
//
行为 或者 成员方法
}
class为定义类的关键字，ClassName为类的名字，{}中为类的主体。类中包含的内容称为类的成员。属性主要是用来描述类的，称之为类的成员属性或者类成员变量。方法主要说明类具有哪些功能，称为类的成员方法。
Tips：
1.类名注意采用大驼峰定义。
2.成员前写法统一为
public。
3.此处写的方法不带
static
关键字。
下面我们举个例子让大家熟悉熟悉，接下来我们定义一个学生类。
public class Student {//学生类
public String name;
public String gender;
public short age;
public double score;
public void DoClass() {
System.out.println("按时上课，不要迟到，如果请假，及时去补");
}
public void DoHomework() {
System.out.println("教务系统，完成作业，一旦拖沓，神仙难救");
}
public void Exam() {
System.out.println("考试目的，了解学情，人人必考，暴露问题");
}
}
注意事项：
1.
一般一个文件当中只定义一个类，
2. main
方法所在的类一般要使用
public
修饰
(
注意：
Eclipse
默认会在
public
修饰的类中找
main
方法
)，
3. public
修饰的类必须要和文件名相同，
4.
不要轻易去修改
public
修饰的类的名称
。
三、类的实例化
1.类的实例化介绍
定义了一个类，就相当于在计算机中定义了一种新的类型，有了这些自定义的类型之后，就可以使用这些类来定义实例
(
或者称为对象
)，
用类类型创建对象的过程，称为类的实例化
，在
java
中采用
new
关键字，配合类名来实例化对象。
class Person {
public String name;
public int age;
}
public class Test {
public static void main(String[] args) {
Person person1 = new Person();
Person person2 = new Person();
Person person3 = null;
}
}
这里Person 就是一个类，它里面的 name 和 int 就是类的成员，这里的 person1 就是引用，它指向后面 new 的对象，因为是引用，所以也可以指向 null 。而这里的person3就是指向空（null）引用。person1、person2、person3就是实例化的对象。
2.成员初始化
我们在创建类里的这些成员的时候就可以对它们进行初始化。
class Student {
public String name = "张三";
public int age = 18;
}
上面就是我们创建学生类的成员时，对它们进行初始化。但小欣不建议大家一开始救直接初始化，而是在类的调用者使用的时候再初始化。具体的代码如下：
class Student {
public String name;
public int age;
}
public class Test {
public static void main(String[] args) {
Student student = new Student();
student.name = "张三";
student.age = 18;
System.out.println(student.name);
System.out.println(student.age);
}
}
运行结果如下：
我们在类的调用者里面对类的成员进行赋值，然后在 main 方法当中，通过引用来进行调用。
3.类中方法的实现
我们可以在类的里面写一个方法，调用这个方法后，直接返回名字和年龄。方法如下：
class Student {
public String name;
public int age;
public void func() {
System.out.println("姓名：" + name + " 年龄：" + age);
}
}
public class Test {
public static void main(String[] args) {
Student student = new Student();
student.name = "张三";
student.age = 18;
student.func();
}
}
运行结果如下：
当我们要输出姓名和年龄的时候，就一个一个地去调用输出，直接调用类中的这个方法就可以。
四、封装
1.private实现封装
private是用来修饰成员变量或方法的关键字，被private修饰之后，就不能被类外的调用者访问了，这样就可以配合 public 来实现对外的接口。
我们可以这样理解：
1.public
：一个人的外貌特征，谁都可以看得到
2.default:
对于自己家族中
(
同一个包中
)
不是什么秘密，但对于其他人来说就是隐私了
3.private
：只有自己知道，其他人都不知道。
下面我们通过一个例子来帮助我们更好的理解。
class Student {
private String name = "张三";
private int age = 18;
public void func() {
System.out.println("姓名：" + name + " 年龄：" + age);
}
}
public class Test {
public static void main(String[] args) {
Student student = new Student();
student.func();
}
}
运行结果：
上面我们通过利用private的封装属性，使其只能在类里面被访问到。后面的public方法让类的调用者在类外就可以访问到了。所以在类外直接调用func方法就可以输出结果。
2.getter和setter方法
我们把类里面的成员设置为private的属性时，就不能再类外面对它们进行初始化，但我们想在类外将这些成员赋其他的值，我们就可以使用getter和setter方法。
getter ：在类外面获取成员变量的值
setter ：在类外直接调用此方法，然后设置一个值。
class Student {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void func() {
System.out.println("姓名：" + name + " 年龄：" + age);
}
}
public class Test {
public static void main(String[] args) {
Student student1 = new Student();
Student student2 = new Student();
student1.setName("张三");
student1.setAge(10);
student1.func();
student2.setName("李四");
student2.setAge(18);
student2.func();
}
}
输出结果：
上面因为private对name和age做了封装，所有我们调用setter方法，在类外进行访问。在Java中我们如果使用在类里使用privata对成员变量进行封装，可以鼠标右键点击Generate，选择Getter和Setter，然后选择哪些成员变量要生成Getter和Setter方法，最后点击OK就自动生成好了，这样让我们在写代码是更加方法。具体步骤如下：
五、构造方法的使用
1.构造方法的介绍
构造方法
(
也称为构造器
)
是一个特殊的成员方法，
名字必须与类名相同，在创建对象时，由编译器自动调用，并且
在整个对象的生命周期内只调用一次。
注意：构造方法的作用就是对对象中的成员进行初始化，并不负责给对象开辟空间。
2.构造方法的特性
构造方法有以下这几种特性：
1.构造方法的名字必须与类名相同，
2.
没有返回值类型，设置为
void
也不行，
3.
创建对象时由编译器自动调用，并且在对象的生命周期内只调用一次
(
相当于人的出生，每个人只能出生一次
)，
4.
构造方法可以重载
(
用户根据自己的需求提供不同参数的构造方法
)，
5. 如果用户没有显式定义，编译器会生成一份默认的构造方法，生成的默认构造方法一定是无参的，
6.
构造方法中，可以通过
this
调用其他构造方法来简化代码，
7.绝大多数情况下使用
public
来修饰，特殊场景下会被
private
修饰。
注意：一旦用户定义，编译器则不再生成。
下面实现一个不带参数的构造方法：
class Student {
public Student() {
System.out.println("这是不带参数的构造方法");
}
}
public class Test {
public static void main(String[] args) {
Student student = new Student();
}
}
输出结果如下：
我们在实例化类的对象的时候调用它的构造方法，因为上面我们自己写了构造方法，所以这里就调用我们写过的。但要注意：如果我们没有写构造方法，编译器会自己帮我们默认生成不带参数的构造方法。所以一个类，至少会有一个构造方法。
既然可以实现不带参数的构造方法，也就有带参数的构造方法，具体如下所示：
class Student {
private String name;
public Student(String name) {
this.name = name;
System.out.println("Studnet(Sting)带一个参数的构造方法");
}
}
public class Test {
public static void main(String[] args) {
Student student = new Student("张三");
}
}
输出结果：
在类初始化的时候，传入参数 "张三" 在类实例化的时候就可以调用带参数的构造方法 。在Java中，如果想生成一个带参的构造方法，可以通过鼠标右键点击Generate，然后点击Constructor，再点击哪个成员要带参数，最后点OK就会自动生成一个带参数的构造方法。具体步骤如下：
六、this引用
1.this的介绍
在类当中this表示当前对象的引用（不是当前对象），我们可以通过this来访问类当中的成员变量和方法。通过使用this可以增加我们代码的可读性。当我们在使用getter和setter的时候，就会用 this。
class Student {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void func() {
System.out.println("姓名：" + name + " 年龄：" + age);
}
}
public class Test {
public static void main(String[] args) {
Student student1 = new Student();
student1.setName("张三");
student1.setAge(10);
student1.func();
}
}
2.this的特性
this的几个特性：
1. this
的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型，
2. this
只能在
"
成员方法
"
中使用，
3.
在
"
成员方法
"
中，
this
只能引用当前对象，不能再引用其他对象，
4. this
是
“
成员方法
”
第一个隐藏的参数，编译器会自动传递，在成员方法执行时，编译器会负责将调用成员方法，对象的引用传递给该成员方法，this
负责来接收。
七、static静态关键字
在
Java
中，被
static
修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对
象，是所有对象所共享的，静态成员一般是通过 静态方法来访问的。static可以修饰属性，方法。
划重点：static 修饰的变量通过类名访问。
我们一起看看下面这个例子：
class Student {
private String name;
private int age;
private static String classRoom="高三10班";
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public static String getClassRoom() {
return classRoom;
}
public void func() {
System.out.println("姓名：" + name + " 年龄：" + age);
}
}
public class Test {
public static void main(String[] args) {
Student student = new Student();
student.setName("王五");
student.setAge(18);
student.func();
System.out.println(Student.getClassRoom());
}
}
运行结果如下：
所以我们在写代码时，当使用static来修饰方法的时候，不需要再创建对象，直接拿类名调用就可以。
八、总结
类与对象是JavaSE的基础之一，了解并掌握类与对象的概念和使用方法对于Java程序设计是非常重要的。我们写程序时合理的设计和使用类与对象，可以提高我们代码的可读性和可扩展性，进而实现更加灵活和高效的程序设计。今天对Java中的类与对象就分享到这里，感谢大家对蜡笔小欣的关注、鼓励与支持！我也会继续创作并跟大家分享，我们下次再见！！！
精彩内容
您阅读本篇文章共花了：
发表评论