目录
学习Java的类的定义、对象的创建与使用、对象的引用传递、访问控制、封装性、构造方法
一、类与对象
1、类的定义
在面向对象的思想中最核心的就是对象，而创建对象的前提是需要定义一个类，类是Java中一个重要的引用数据类型，也是组成Java程序的基本要素，所有Java程序都是基于类的。
类是对象的抽象，用于描述一组对象的共同特征和行为。类中可以定义成员变量和成员方法，其中，成员变量用于描述对象的特征，成员变量也被称为对象的属性；成员方法用于描述对象的行为，可简称为方法。
类的定义格式
class 类名{
成员变量;
成员方法;
}根据上述格式定义一个学生类，成员变量包括姓名（name）、年龄（age）、性别（sex）；成员方法包括读书read（）示例：
public class Student {
String name; // 成员变量name 表示姓名
int age = 30; //成员变量age 表示年龄
String sex; // 成员变量sex 表示性别
// 定义read () 方法
void read (){
int age = 20; // 局部变量age
System.out.println("大家好,我叫" + name + "," + age + "岁");
}
}上述代码中定义了一个学生类。其中，Student是类名，name、age、sex是成员变量，read（）是成员方法。在成员方法read（）中可以直接访问成员变量name。
上述代码中，在Student类的read方法中有一条打印语句，访问了变量age，此时访问的是局部变量age，也就是说当有另一个程序调用read（）方法时，输出的age值为50，而不是30。
2、对象的创建与使用
定义一个Student01类，想要有类必须要有对象。
语法格式
类名 对象名称 = null ;
对象名称 = new 类名( ) ;上述格式中，创建对象分为声明对象和实例化对象两步，也可以直接通过下面的方式创建对象。
语法格式
类名 对象名称 = new 类名( ) ;例如，创建Student01类的实例对象
Student01 stu = new Student01 ( ) ;
上述代码中，new Student01 ( ) 用于创建Student01 类的实例对象，Student01 stu 则是声明了一个Student01类的变量stu。运算符 “ = ” 将创建的Student01对象地址赋值给变量stu，变量stu引用的对象简称stu对象。
示例：
class Student01 {
String name; // 声明姓名属性
void read() {
System.out.println("大家好,我是" + name + ",我在看书！");
}
}
public class Test {
public static void main(String[] args) {
Student01 stu = new Student01(); //创建并实例化对象
}
}上述代码 main ( ) 方法中实例化一个Student 对象，对象名称为stu。使用new 关键字创建的对象在堆内存分配空间。
stu对象的内存分配
对象名称stu保存在栈内存中，而对象的属性信息则保存在对应的堆内存中。
创建Student01对象后，可以使用对象访问类中的某个属性方法，对象属性和方法的访问通过 “ . ” 运算符实现
语法格式
对象名称 . 属性名
对象名称 . 方法名示例：
class Student01 {
String name; // 声明姓名属性
void read() {
System.out.println("大家好,我是" + name + ",我在看书！");
}
}
public class Example01 {
public static void main(String[] args) {
Student01 stu1 = new Student01(); //创建对象
Student01 stu2 = new Student01();
//访问
stu1.name = "小明"; //为stu1 对象的name 属性赋值
stu1.read(); //调用对象的方法
stu2.name = "小华";
stu2.read();
}
}
结果：
3、对象的引用传递
类属于引用数据类型，引用数据类型就是指内存空间可以同时被多个栈内存引用。
class Student01 {
String name; // 声明姓名属性
int age = 30; //成员变量age 表示年龄
void read() {
System.out.println("大家好,我" + age + "了");
}
}public class Example02 {
// 对象引用的传递
public static void main(String[] args) {
Student01 stu1 = null;
Student01 stu2 = new Student01();
stu1 = stu2; // 同一个对象，修改对两个对象都有效
stu2.name = "小明";
stu2.age = 20;
stu2.read(); // 调用对象的方法，结果是值20
stu2.age=30; //修改 结果是 stu1是age值是30
System.out.println("stu1是name值是" +stu1.name);
System.out.println("stu1是age值是" +stu1.age);
// stu2.age=30; // 放在这里运行结果没有被修改
stu2.read(); //访问的是Student中定义的局部变量 int age = 30;
}
}一个栈内存空间只能指向一堆内存空间，如果想要在指向其他堆内存空间，就必须先断开已有的指向后再分配新的指向。
4、访问控制
针对类、成员方法和属性，Java提供了4种访问控制权限，分别是 private 、 default 、 protected 和 public 。
4种访问控制权限
（1）private : private属于私有访问权限，用于修饰类的属性和方法。类的成员一旦使用了private关键字修饰，则该成员只能在本类中进行访问。
（2）default : default属于默认访问权限。如果一个类中的属性或方法没有任何的访问权限声明，则该属性或方法就是默认的访问权限，默认的访问权限可以被本包中的其他类访问，但是不能被其他包的类访问。
（3）protected : 属于受保护的访问权限。一个类中的成员使用了protected访问权限，则只能被本包及不同包的子类访问。
（4）public : public属于公共访问权限。如果一个类中的成员使用了public访问权限，则该成员可以在所有类中被访问，不管是否在同一包中。
总结上述的访问控制权限
| 访问范围 | private | default | protected | public |
|---|---|---|---|---|
| 同一类中 | ✓ | ✓ | ✓ | ✓ |
| 同一包中的类 | ✓ | ✓ | ✓ | |
| 不同包中的子类 | ✓ | ✓ | ||
| 全局范围 | ✓ |
示例：演示4种访问控制权限修饰符的用法
public class Test {
public int aaa; //aa可以被所有的类访问
protected boolean bb; //可以被所有子类以及本包的类使用
void cc (){ // default 访问权限，能在本包范围内使用
System.out.println("包访问权限");
}
// private 权限的内部类，即这是私有的内部类，只能在本类使用
private class InnerClass{
}
}需要注意的是，类名Test只能使用public修饰或者不写修饰符。局部成员是没有访问权限控制的，因为局部成员只在其所在的作用域内起作用，不可能被其他类访问到，如果在程序中这样编写代码，编译器会报错。
错误的示例代码如下：
public class Test {
void cc (){ // 默认访问权限，能在本包内使用
public int aaa; //错误，全局变量没有访问控制权限
protected boolean bb; //错误，全局变量没有访问控制权限
System.out.println("包访问权限");
}
// private 权限的内部类，即这是私有的内部类，只能在本类使用
private class InnerClass{
}
}提示：
如果一个Java源文件中定义的所有类都没有使用public 修饰，那么这个Java源文件的文件名可以是一切合法；如果一个源文件中定义了一个public 修饰的类，那么这个源文件的文件名必须与public修饰的类名相同。
二、封装性
1、为什么要封装
在Java面向对象的思想中，封装可以被认为是一个保护屏障，防止本类的代码和数据被外部程序随机访问。
示例：
package com.itheima.example03;
class Student {
String name; //声明姓名属性
int age; //声明年龄属性
void read() {
System.out.println("我是" + name + "," + age + "岁了");
}
}
package com.itheima.example03;
public class Example03 {
public static void main(String[] args) {
Student stu = new Student();
stu.name = "张三"; // 为对象的name属性赋值
stu.age =20; // 为对象的age属性赋值
stu.read(); // 调用对象的方法
}
}
将年龄赋值为-18岁，这在程序中是不会有任何问题的，因为int的值可以负数。但是在现实中，-18明显是一个不合理的年龄值。为了避免这种错误的发生，在设计Student类时，该对成员变量的访问做出一些限定，不允许外界随意访问，这就需要实现类的封装。
2、如何实现封装
类的封装是指将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象的内部信息，
而是通过类提供的方法实现对内部信息的操作访问。
在Java开发中，在定义一个类时，将类中的属性私有化，即使用private关键字修饰类的属性，被私化的属性只能在类中被访问。如果外界想要访问私有属性，则必须通过setter和 getter方法设置和获取性值。
示例：使用private关键字修饰 name属性和age属性，实现类的封装
// 封装
class Student {
// private 私有访问
private String name; //声明姓名属性
private int age; //声明年龄属性
//获取name属性
public String getName() {
return name;
}
//设置name属性
public void setName(String name) {
this.name = name;
}
//获取age属性
public int getAge() {
return age;
}
//设置age属性
public void setAge(int age) {
if (age <= 0){
System.out.println("您输入的年龄有误！");
// System.exit(0); //退出程序 如果年龄是-19 直接退出程序则不会进行后面的访问
} else {
this.age = age;
}
}
public void read(){
System.out.println("我是" + name + "," + age + "岁了");
}
}public class Example04 {
public static void main(String[] args) {
Student stu = new Student();
Student stu1 = new Student();
stu.setName("张三"); // 为对象的name属性赋值
System.out.println(stu.getName()); //打印张三
stu.setAge(20); // 为对象的age属性赋值
System.out.println(stu.getAge()); //打印年龄
stu.read(); // 调用对象的方法
stu1.setName("李四");
stu1.setAge(19);
stu1.read();
}
}
当调用setAge( ) 方法传入了-18 这个负数后，age 显示为初始值0 。这是因为setAge( ) 方法对参数 age 进行了判断，如果 age 的值小于或等于 0 ，打印 “ 您输入的年龄有误！ ”，并将 age 设置为 0。
自动生成封装方法
右键打开
点击
可以Ctrl + A 全选，然后点击ok
三、构造方法
从前面所学的知识可以发现，实例化一个对象后，如果要为这个对象中的属性赋值，必须通过
直接访句对象的属性或调用setter方法才可以实现，如果需要在实例化对象时为这个对象的属性赋
值，可以通过构造方法实现。构造方法(也称为构造器)是类的一个特殊成员方法，在类实例化对象
时自动调用。
1、定义构造方法
构造方法是一个特殊的成员方法，在定义时，有以下几点需要注意。
（1）构造方法的名称必须与类名一致。
（2）构造方法名称前不能有任何返回值类型的声明。
（3）不能在构造方法中使用return返回一个值，但是可以单独写return语句作为方法的结束。
示例：构造方法的定义
package com.itheima.example005;
class Student{
public Student(){
System.out.println("调用了无参数构造方法");
}
}
public class Example005 {
public static void main(String[] args) {
System.out.println("声明对象...");
Student stu = null; //声明对象
System.out.println("实例化对象...");
stu = new Student(); //实例化对象
}
}
示例：有参数结构的定义与调用
package com.itheima.example05;
// 构造方法
class Student{
String name;
int age;
public Student(){ //无参的构造方法
System.out.println("调用了无参的构造方法");
}
public Student(String n){ //有参数的构造方法
name = n;
}
public Student(String name, int age){ //有参数的构造方法
this.name = name;
this.age = age;
}
public void read(){
System.out.println("我是"+name+","+age+"岁");
}
}
public class Example05 {
public static void main(String[] args) {
Student stu1 = null; //声明一个对象
// Student stu1 = new Student(); //不用在前面声明Student,直接实例化对象
stu1 = new Student(); //任何一个类都默认有一个无参的构造方法，如果我们在类中写了构造方法，那么默认的构造方法不起作用
stu1.name = "张三"; //为name对象赋值
stu1.age = 20; //为age对象赋值
stu1.read(); // 调用访问对象stu1
Student stu2 = new Student("李四",19); //实例化对象 前面要有构造方法 运行结果我是李四,19岁
stu2.read(); // 调用访问对象stu2
Student stu3 = new Student("王五"); //前面要有构造方法 选中然后 ctrl+Alt+v
stu3.read(); // 调用访问对象stu3
}
}
自动生成构造方法
右键打开
点击
可以Ctrl + A 全选，然后点击ok
2、构造方法的重载
与普通方法一样，构造方法也可以重载，在一个类中可以定义多个构造方法，只要每个构造方法的参数类型或参数不同即可。可以通过调用不同的构造方法为不同的属性赋值。
示例：构造方法的重载
package com.itheima.example07;
class Student{
private String name;
private int age;
//无参数的构造方法
public Student(){ }
//有参数的构造方法
public Student(String n) {
name = n;
}
//有参数的构造方法
public Student(String n, int a) {
name = n;
age = a;
}
public void read(){
System.out.println("我是:"+name+",年龄:"+age);
}
}
public class Example07 {
public static void main(String[] args) {
Student stu1 = new Student("张三");
Student stu2 = new Student("张三",18); //实例化对象
stu1.read();
stu2.read(); //访问调用对象
}
}
120
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
