认识类和对象
1.类、对象是什么？
类在Java中，也叫做自定义类型。
类就是一类对象的统称，对象就是这一类具体化的一个个例
可以把类想象成一个模板，把对象想象成实体，比如：建房子，会有图纸，然后根据图纸去建房子，一张图纸可建很多同样的房子。而图纸就是"类"，建的房子就是"实体"，通过一个类可以产生多个对象
2.什么是面向对象？
之前在初始Java篇简单讲述了Java的面向对象性，对比了面向对象和面向过程的不同
这里就不多说了 ：https://blog.csdn.net/m0_47988201/article/details/118996045?spm=1001.2014.3001.5501.
面向对象是思考问题的一种方式，是一种思想
总的来说，面向对象就是用代码(类)，来描述客观世界事物的一种方式，一个类主要包含一个事物的属性和行为
面向对象的好处是：将复杂的事情简单化，只要面对一个对象就行
之后，会从这三点进行深入学习：找对象—创对象—使用对象
3.一个对象的产生过程是？
①给对象分配内存；
②调用合适的构造方法
🔺OOP语言的三大特征？
OOP：面向对象编程
三大特性：继承、封装、多态
类和对象的实例化
类的定义：
在Java中定义类，需要 class 关键字
类中包含的内容称为类的成员；属性主要是用来描述类的，称之为类的成员属性或者类成员变量；方法主要说明类具有哪些功能，称为类的成员方法
类的成员包括：字段、方法、代码块、内部类和接口等，此处只介绍前三个
语法格式：
class ClassName {
field ； …// 字段(成员属性) / 成员变量
method；// 行为 / 成员方法
}
举例：
class Person{
//字段
String name;
int age;
//行为
public void eat(){
System.out.println("eat()!");
}
public void sleep(){
System.out.println("sleep()!");
}
}
注意：
- 类名使用大驼峰命名法
- 字段 / 成员变量定义在方法外面、类的里面
- 实例成员变量存放在对象里
- Java中访问修饰限定符：
private：私有的；public：共有的；protected：受保护的；什么都不写：默认权限 / 包访问权限 - 一般一个文件当中只定义一个类
- main方法所在的类必须要使用public修饰
- public修饰的类必须要和文件名相同
实例化对象：
在Java中，通过关键字new，配合类名可以实例化一个对象
用类类型创建对象的过程，称为类的实例化
//实例化对象
Person person1 = new Person();
Person person2 = new Person();
Person person3 = new Person();
Person person4 = new Person();
①如何访问对象中的实例成员变量？
通过对象的引用即可访问： 对象的引用 . 成员变量
public static void main(String[] args) {
//实例化一个对象
Person person = new Person();
//访问对象中的实例成员变量
//通过对象的引用
System.out.println(person.age);
System.out.println(person.name);
}
②如何访问静态的数据成员？
类名 . 静态成员变量
public static void main(String[] args) {
Person per = new Person();
System.out.println(Person.size);
}
注意：
- 同一个类可以创建多个实例
- new 关键字用于创建一个对象的实例
- 实例成员变量，没有初始化，默认值为对应的 0 值
引用类型默认为null，简单类型默认为 0
特殊：char类型—"\u0000"；boolean类型—false - 使用 . 来访问对象中的属性和方法
- 静态成员变量不属于对象，属于类，且只有一份
方法：
实例成员方法：
public void eat(){
System.out.println("eat()!");
}
public void sleep(){
System.out.println("sleep()!");
}
静态成员方法
静态成员方法
public static func(){
System.out.println("static::func()!");
}
🔺构造方法
构造方法的方法名和类名相同，且没有返回值
构造方法作用： 实例化一个对象
class Person{
private String name;
private int age;
public Person(){
System.out.println("Person!");
}
public Person(String name,int age){
this.name = name;
this.age = age;
System.out.println("Person<String,int>");
}
public class Test {
public static void main(String[] args) {
//写这行代码的时候，就会调用构造方法
Person person1 = new Person();
Person person2 = new Person("Huahua",18);
}
}
注意：
- 当没有提供构造方法的时候，编译器会自动提供一个没有参数的构造方法
- 若类中定义了构造方法，则默认的无参构造不再产生
- 什么时候调用构造方法取决于new对象时是否给参数
- 构造方法支持重载，规则和普通方法一致
①访问实例成员方法
通过对象的引用进行访问：对象的引用 . 实例成员方法
public static void main(String[] args) {
Person per = new Person();
per.eat();
per.sleep();
}
②访问静态成员方法
类名 . 静态成员方法
public static void main(String[] args) {
Person.func();
}
static 关键字
1.修饰属性：
Java静态属性和类相似，和具体的实例无关
即：同一个类的不同实例共用同一个静态属性
class Test{
public int a = 0;
public static int count;
}
静态成员变量只有一份：
public static void main(String[] args) {
Test T = new Test();
T.a++;
Test.count++;
System.out.println(T.a+" "+Test.count);
}
输出结果：
分析原因：
2.修饰方法：
在方法前应用 ststic 关键字，就把该方法称为静态方法
静态成员方法
public static func(){
System.out.println("static::func()!");
}
注意：
- 静态方法内部不能访问非静态成员
- 静态方法属于类，不属于类的对象
- 可以直接调用静态方法，而无需创建类的实例
- 静态方法可以更改静态数据成员的值
- 静态方法中不能调用任何非静态方法
this 关键字
this 表示当前对象的引用
this 使用方法：
- this . 属性名称 访问属性，指的是访问类中的成员变量，用来区分成员变量和局部变量
- this . 方法名称 用来访问本类的成员方法
- this()；访问本类的构造方法，()中可以有参数的 如果有参数 就是调用指定的有参构造
举例1
访问属性 和 访问方法
class Person{
private String name;
private int age;
//调用属性
public Person(String name, int age) {
this.name = name;
this.age = age;
}
//调用方法
public void eat{
System.out.println(this.getName());
}
public String getName{
return name;
}
}
举例2
访问构造方法
class Person{
private String name;
private int age;
public Person(){
// 访问构造方法
this("Huahua",3);
System.out.println("Person!");
}
public Person(String name,int age){
this.name = name;
this.age = age;
System.out.println("Person<String,int>");
}
}
注意事项：
- this() 不能使用在普通方法中 只能写在构造方法中
- this() 必须是构造方法中的第一条语句
getter 和 setter方法
当我们使用 private 来修饰字段的时候，就无法直接使用这个字段了，这就需要使用 getter 和 setter 方法
class Person{
private String name;
//setter方法给设施变量的值
public String getName{
return name;
}
public void setName(String name){
this.name = name;
}
}
注意事项：
- getName 即为 getter 方法，表示获取这个成员的值
- setName 即为 setter 方法，表示设置这个成员的值
- 不是所有的字段都一定要提供 setter / getter 方法，而是要根据实际情况决定提供哪种方法
- 当 setter 方法的形参名字和类中的成员属性的名字一样时，如果不适用 this，相当于自赋值，this表示当前实例的引用
- 在IDEA中，可以使用
Alt+F12，快速生成 setter / getter 方法
封装
封装：用 private 来修饰属性 / 方法
类和对象阶段，主要研究的就是封装特性
class Student{
private String name;
public int age;
public void func1(){
System.out.println("func1()");
}
}
如果一个属性 / 方法被 private 修饰之后，限定只能在类当中来使用
封装的实现步骤：
- 修改属性的可见性——设为private
- 创建getter / setter方法——用于属性的读写
- 在getter / setter方法中加入属性控制语句——对属性值的合法性进行判断
举例：
class Student{
//成员变量私有化
private int age;
//setter方法给设施变量的值
public void setAge(int age){
if(age < 0){
System.out.println("年龄无效！");
}
else{
this.age = age;
}
}
//提供一个公开的接口
//使用getter方法获取赋值
public int getAge(){
return age;
}
}
public class Test {
public static void main(String[] args) {
Student student = new Student();
//检验
student.setAge(-10);
System.out.println(student.getAge());
}
}
输出结果：
Java中的访问修饰符：
| 访问修饰符 | 本类 | 同包 | 子类 | 其他 |
|---|---|---|---|---|
| private | √ | |||
| public | √ | √ | √ | √ |
| protected | √ | √ | √ | |
| 默认 | √ | √ |
封装的作用：
- 对象的数据封装特性，提高了程序的可复用性和可维护性，降低了程序员保持数据与操作内容的负担
- 对象的数据封装特性还可以把对象的私有数据和公共数据分离开，保护了私有数据，减少了可能的模块间干扰，达到降低程序复杂性、提高可控性的目的
建议：以后在设计类的时候，无特殊要求，所有的属性虽好都设置为私有的private ，一定要体现封装
代码块
使用 { } 定义的一段代码称为代码块
重点掌握代码块执行的先后顺序
分为四种：
普通代码块：在方法或语句中出现的{ }就称为普通代码块
实例代码块 (构造代码块)
静态代码块
同步代码块
实例代码块：
定义在类中且没有加static关键字的代码块
如果存在多个构造代码块，执行顺序由他们在代码中出现的次序决定，先出现先执行
特性：
{
System.out.println("实例代码块......");
}
注意事项：
- 实例代码块优先于构造方法执行，因为编译完成后，编译器会将实例代码块中的代码拷贝到每个构造方法第一条语句前
- 实例代码块只有在创建对象时才会执行
静态代码块：
static {
System.out.println("静态代码块......");
}
注意事项：
- 静态代码块不能存在于任何方法体内
- 静态代码块不能直接访问实例变量和实例方法，需要通过类的实例对象来访问
- 静态代码块不管生成多少个对象，其只会执行一次
- 静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
- 如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次合并，最终放在生成的<>方法中，该方法在类加载时调用，并且只调用一次
静态 / 实例代码块异同点
相同点： 都是JVM加载类后且在构造函数执行之前执行，在类中可定义多个，一般在代码块中对一些static变量进行赋值
不同点： 静态代码块在非静态代码块之前执行，静态代码块只在第一次 new 时执行一次，之后不在执行。而非静态代码块每new一次就执行一次
本篇内容有些多，哪里有什么问题欢迎大家指正~