Java 面向对象基础知识学习笔记整理
Java 面向对象基础知识整理，包含类，对象的定义和创建，局部变量和成员变量的区别以及构造方法，this 关键字的用法
文章目录
- 概述：
- 类和对象
- 类的定义
- 对象的创建
- 对象作为方法的参数
- 对象作为方法的返回值
- 局部变量和成员变量
- 封装性
- this 关键字
- 构造方法
- 定义标准类
概述：
面向过程：当需要实现一个功能的时候，每一个具体的步骤都要亲力亲为，详细处理每一个细节
面向对象：当需要实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人，来帮我做事。
面向过程思想
自己实现自己想要的功能
public class test {
// main
public static void main(String[] args) {
// 新创建一个数组 arrayA
int[] arrayA = new int[] {1, 2, 3, 4, 6};
System.out.print("[");
for (int i = 0; i < arrayA.length; i++) {
if (i == arrayA.length - 1) {
System.out.print(arrayA[i] + "]");
}else {
System.out.print(arrayA[i] + ", ");
}
}
}
}
输出：
[1, 2, 3, 4, 6]
面向对象思想
使用 JDK 给我们提供好的 Arrays 类里面的 toString 方法可以直接打印出数组
import java.util.Arrays;
public class test {
// main
public static void main(String[] args) {
// 新创建一个数组 arrayA
int[] arrayA = new int[] {1, 2, 3, 4, 6};
System.out.println(Arrays.toString(arrayA));
}
}
输出：
[1, 2, 3, 4, 6]
特点：面向对象是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者，面向独享的语言中，包含了三大基本特征，封装、继承和多态。
类和对象
类：是一组相关属性和行为的集合，可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物
对象：是一类事物的具体体现，对象是类的一个实例
类的定义
成员变量（属性）
成员变量是直接定义在类里面的，在方法外边
成员方法（行为）
成员方法不写 static 关键字
注意：在一般写方法的时候，我们用的都是 public static void function() {} 来定义一个方法，但是在成员方法中，我们用 public void function() {} 来定义。
// 定义一个学生类
public class Student {
// 成员变量
String name;
int age;
// 成员方法
public void study() {
System.out.println("学习！");
}
public void sleep() {
System.out.println("吃饭！");
}
}
对象的创建
一个类定义好了是不能直接使用的，需要根据类创建出对象，才能使用
1、导入包
import 包名称.类名称
例如： import java.util.Arrays;
（要使用的类和自己位于同一个包下的话，导包语句省略不写）
2、创建格式
类名称 对象名 = new 类名称();
例如： Student stu = new Student();
3、使用
使用成员变量：对象名.成员变量名
使用成员方法：对象名.成员方法名(参数)
举例
// 定义学生类
public class Student {
// 成员变量
String name;
int age;
// 成员方法
public void study() {
System.out.println("学习！");
}
public void sleep() {
System.out.println("吃饭！");
}
}
public class test {
public static void main(String[] args) {
// 创建对象
Student stu = new Student();
// 访问成员变量
System.out.println("名字为：" + stu.name);
System.out.println("年龄为：" + stu.age);
// 给成员变量赋值
stu.name = "ilblogs";
stu.age = 24;
// 再次打印成员变量
System.out.println("名字为：" + stu.name);
System.out.println("年龄为：" + stu.age);
// 访问成员方法
stu.sleep();
stu.study();
}
}
对象作为方法的参数
当把对象作为参数传进方法时，实际传进去的是对象的地址值
// 定义学生类
public class Student {
// 成员变量
String name;
int age;
// 成员方法
public void study() {
System.out.println("学习！");
}
public void sleep() {
System.out.println("吃饭！");
}
}
public class test {
public static void main(String[] args) {
// 创建对象
Student stu = new Student();
stu.name = "charlin";
stu.age = 33;
printInfo(stu);
}
// 创建一个方法，用对象作为参数
public static void printInfo(Student student1) {
System.out.println("名字为：" + student1.name);
System.out.println("年龄为：" + student1.age);
}
}
对象作为方法的返回值
// 定义学生类
public class Student {
// 成员变量
String name;
int age;
// 成员方法
public void study() {
System.out.println("学习！");
}
public void sleep() {
System.out.println("吃饭！");
}
}
public class test {
public static void main(String[] args) {
// 创建对象
Student stu = getStudent();
System.out.println(stu.name);
System.out.println(stu.age);
}
// 创建一个方法
public static Student getStudent() {
Student stu = new Student();
stu.name = "Tom";
stu.age = 15;
return stu;
}
}
局部变量和成员变量
区别：
1、定义的位置不一样
局部变量：在方法的内部
陈冠变量：在方法的外部，直接写在类当中
2、作用范围不一样
局部变量：只有方法当中才可以使用，出了方法之后就不能再用
成员变量：整个类全部可以通用
3、默认值不一样
局部变量：没有默认值，如果要想使用默认值，必须手动进行赋值
成员变量：如果没有赋值，会有默认值，规则和数组一样
4、内存的位置不一样
局部变量：位于栈内存
成员变量：位于堆内存
5、生命周期不一样
局部变量：随着方法进栈而诞生，随着方法出栈而被销毁
成员变量：随着对象创建而诞生，随着对象被垃圾回收而消失
封装性
封装：就是把一些细节性的实现隐藏起来，使结构看起来更加清晰
1、方法就是一种封装
public class test {
public static void main(String[] args) {
int[] arrayA = {5, 14, 19, 32, 66};
System.out.println("最大值为：" + getMax(arrayA));
}
// 获取最大值
public static int getMax(int[] array) {
int max = array[0];
for (int i = 1; i < array.length; i++) {
if (max <= array[i]) {
max = array[i];
}
}
return max;
}
}
2、关键字 private 也是一种封装
在定义成员变量时，无法阻止一些不合理的数值被设置进来，那么我们就用 private 对成员变量进行修饰，
使用 private 进行修饰后的成员变量，在本类当中可以随意访问，但是，超出本类范围后就不能直接访问。
// 定义 Person 类
public class Person {
// 成员方法
String name;
int age;
public void show() {
System.out.println("名字：" + name + ", 年龄：" + age);
}
}
public class test {
public static void main(String[] args) {
Person man = new Person();
man.name = "Alex";
man.age = 26;
man.show();
}
}
输出：
名字：Alex, 年龄：26
但如果用 private 进行成员变量的修饰后，在其他类种只有对该成员变量访问控制的权限，没有修改的权限
所以，我们可以用下面方法来进行成员变量的设置，间接访问成员变量
// 创建 Person 类
public class Person {
// 成员方法
String name;
private int age;
public void show() {
System.out.println("名字：" + name + ", 年龄：" + age);
}
// 设置 private 修饰后成员变量
public void setAge(int num) {
age = num;
}
// 获取 private 修饰后的成员变量
public int getAge() {
return age;
}
}
public class test {
public static void main(String[] args) {
Person man = new Person();
man.name = "Alex";
// man.age = 26; // 错误写法
man.setAge(52); // 正确写法
man.show();
}
}
但是上面这种写法反而显得更臃肿，没有用处，其实，在实际写法中，我们写 private 的目的更多的是对数据的检验。例如在上面的代码中，我们实现的是设置年龄，如果年龄为负，那么就不是我们想要的数据。
间接访问即是在成员变量所在内中定义 Setter 和 Getter 方法
Setter：不能有返回值，参数类型和成员变量对应
Getter：不能有参数，返回值类型和成员变量对应
（注意：对于布尔型的用 private 修饰过的成员变量，我们在定义它的 Getter 方法时，应该写成 isxxx 形式）
如下：
public class Person {
// 成员方法
String name;
private int age;
private boolean male;
public void show() {
System.out.println("名字：" + name + ", 年龄：" + age);
}
public void setMale(boolean attr) {
male = attr;
}
public void isMale() {
return male;
}
// 设置 private 修饰后成员变量
public void setAge(int num) {
if (num < 100 && num >=9) {
age = num;
}else {
System.out.println("数据不合理！");
age = 0;
}
}
// 获取 private 修饰后的成员变量
public int getAge() {
return age;
}
}
public class test {
public static void main(String[] args) {
Person man = new Person();
man.name = "Alex";
// man.age = 26; // 错误写法
man.setAge(-1);
man.show();
}
}
输出：
数据不合理！
名字：Alex, 年龄：0
this 关键字
当方法的局部变量和类的成员变量重名的时候，根据“就近原则”，优先使用局部变量，如果访问本类当中的成员变量，需要使用格式 this.成员变量名
通过谁调用的方法，谁就是 this
public class Person {
String name;
public void sayHello(String who) {
System.out.println(who + "，你好，我叫 " + name);
}
}
public class test {
public static void main(String[] args) {
Person man = new Person();
man.name = "A";
man.sayHello("B");
}
}
输出：
B，你好，我叫 A
但如果在 Person 类中的 sayHello(String who) 改成 sayHello(String name) 后，参数的 name 和 成员变量 name 就重合了，那根据就近原则输出的自然就是局部变量的 name。
那么我们就可以用 this.name 来代替成员变量的 name
(main 方法和上面一致)
public class Person {
String name;
public void sayHello(String name) {
System.out.println(name + "，你好，我叫 " + this.name);
}
}
输出：
B，你好，我叫 A
构造方法
构造方法是专门用来创建对象的方法，当我们通过关键字 new 来创建对象时，其实就是在调用构造方法
格式：
public 类名称(参数类型 参数名称) {
方法体;
}
注意事项：
1、构造方法的名称必须和所在的类名称完全一样，大小写一致
2、构造方法不要写返回值类型，void 也不要
3、构造方法不能 return 一个具体的返回值
4、如果没有编写任何构造方法，编译器将会默认创建构造方法，只是方法体为空
5、如果编写了至少一个构造方法，那么编译器的默认构造方法就会被覆盖
6、构造方法也是可以进行重载的
public class Student {
// 定义成员变量
private String name;
private int age;
// 无参数的构造方法
public Student() {
System.out.println("无参数的构造方法！");
}
// 有参数的构造方法
public Student(String name, int age) {
System.out.println("有参数的构造方法！");
this.name = name;
this.age = age;
}
// Getter 和 Setter
public void setName(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
public void setAge(int age) {
this.age = age;
}
public int getAge() {
return this.age;
}
}
public class test {
public static void main(String[] args) {
Student stu1 = new Student();
System.out.println("我叫：" + stu1.getName() + "，年龄：" + stu1.getAge());
Student stu2 = new Student("Alex", 23);
System.out.println("我叫：" + stu2.getName() + "，年龄：" + stu2.getAge());
}
}
输出：
无参数的构造方法！
我叫：null，年龄：0
有参数的构造方法！
我叫：Alex，年龄：23
定义标准类
四个部分组成：
1、所有的成员变量都要使用 private 关键字修饰
2、为每一个成员变量编写一对 Getter、Setter 方法
3、编写一个五参数的构造方法
4、编写一个全参数的构造方法
一个标准的类也叫作 Java Bean
以上为 Java 面向对象基础知识整理笔记，如发现错误，请及时留言更改