zeMing

切换外观

Java 面向对象 ​

一、设计对象 ​

定义类注意事项

用来描述一类事物的类，专业叫做 Javabean 类。在Javabean类中，是不写main方法的

java
public class 类名 {
  1、成员变量
  2、成员方法
  3、构造器
  4、代码块
  5、内部类   
}
java
// 在Phone.java中
public class Phone {
  String brand;
  double price;

  public void call() {
    System.out.println("Calling...");
  }
}

// 在PhoneTest.java中
public class PhoneTest {
  public static void main(String[] args) {
    Phone p = new Phone();

    p.brand = "小米";
    p.price = 1999;

    System.out.println(p.brand);
    System.out.println(p.price);

    p.call();
  }
}

1. private 关键字 ​

private 是一个权限修饰符，可以修饰成员（成员变量和成员方法），被 private 修饰的成员只能在本类中才能访问。

针对 private 修饰的成员变量，如果需要被其他类使用，提供相应的操作如：setXxx(参数)、getXxx() 用于获取成员变量的值，方法用public修饰。

java
public class Phone {
  // 成员变量
  private String brand;
  private double price;

  public void setBrand(String brand) {
    // 局部变量
    int num = 10;

    this.brand = brand;
  }
  public String getBrand() {
    return brand;
  }
}
java
public class PhoneTest {
  public static void main(String[] args) {
    Phone p = new Phone();

    p.setBrand("小米");

    System.out.println(p.getBrand());
  }
}

2. 构造方法 ​

如果没有定义构造方法，系统将给出一个默认的无参数构造方法。如果定义了构造方法，系统将不再提供默认的构造方法。

带参构造方法，和无参数构造方法，两者方法名相同，但是参数不同，这叫做构造方法的重载。

无论是否使用，都手动书写无参数构造方法，和带全部参数的构造方法。

快捷生成 Javabean

快捷键：alt + insert / alt + fn + insert

插件：PTG 1秒生成标准 Javabean

java
public class Student {
  private String name;
  private int age;

  public Student() {
    System.out.println("执行了一次");
  }

  public Student(String name, int age) {
    this.name = name;
    this.age = 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;
  }
}
java
public class StudentTest {
  public static void main(String[] args) {
    Student p = new Student();

    Student p1 = new Student("张三", 16);
    System.out.println(p1.getName());
    System.out.println(p1.getAge());
  }
}
练习
java
public class Student {
  private int id;
  private String name;
  private int age;


  public Student() {
  }

  public Student(int id, String name, int age) {
    this.id = id;
    this.name = name;
    this.age = age;
  }

  public int getId() {
    return id;
  }
}
java
public class StudentTest {
  public static void main(String[] args) {
    Student[] arr = new Student[4];

    Student stu1 = new Student(1, "张三", 18);
    Student stu2 = new Student(2, "小米", 18);
    Student stu3 = new Student(3, "阿萨", 18);

    arr[0] = stu1;
    arr[1] = stu2;
    arr[2] = stu3;
    System.out.println(contains(arr, new Student(3, "阿萨", 18)));
  }

  public static boolean contains(Student[] arr, Student stu) {
    for (int i = 0; i < arr.length; i++) {
      if (arr[i].getId() == stu.getId()) {
        System.out.println("已经存在");
        return false;
      }
    }
    return true;
  }
}

二、面向对象进阶 ​

1. static 关键字 ​

static的注意事项

静态方法只能访问静态变量和静态方法

非静态方法可以访问静态变量或者静态方法，也可以访问非静态的成员变量和非静态的成员方法

静态方法中是没有this关键字

用法作用
static 变量所有对象共享，属于类本身
static 方法可以在不创建对象的情况下调用，不能访问非静态成员
static 代码块在类加载时执行一次，用于初始化静态变量
static 内部类可以独立创建对象，不依赖外部类实例
  • 静态变量

被 static 修饰的成员变量，叫做静态变量。

特点：被该类所有对象共享、不属于对象但属于类、随着类的加载而加载，优先于对象的存在。

java
public class Student {
  private String name;
  private int age;
  private String gender;
  public static String teacherName;

  ...
}
java
public class Student {
  public static void main(String[] args) {
    Student.teacherName = "阿伟老师"; // 推荐调用方法 (类名调用)

    Student s1 = new Student();
    s1.setName("张三");
    // s1.teacherName = "阿伟老师"; (对象名调用)
  }
}
  • 静态方法

被 static 修饰的成员方法，叫做静态方法。

特点：多用在测试类和工具类中、Javabean类中很少使用。

java
public class ArrayUtil {
  // 私有化构造方法，目的：为了不让外界创建它的对象
  private ArrayUtil() {}
  
  ...
}

2. 继承 ​

继承是面向对象三大特征之一，可以让类跟类之间产生子父的关系（只支持单继承，不支持多继承，但支持多层继承）。

子类可以得到父类的属性和行为，子类可以使用；子类可以在父类的基础上新增其他功能，子类更强大。

java
public class Cat extends Animal { }

子类到底能继承父类中的那些内容？

非私有private
构造方法❌❌
成员变量✔️✔️
成员方法✔️❌

3. 多态 ​

在这里学习

多态调用成员的特点

1️⃣ 变量调用：编译看左边，运行也看左边。

2️⃣ 方法调用：编译看左边，运行看右边。

java
Animal a = new Dog();

换句话讲

成员变量：在子类的对象中，会把父类的成员变量也继承下来的

成员方法：如果子类对方法进行了重写，那么在虚方法表中是会把父类的方法进行覆盖

java
public class Main {
  public static void main(String[] args) {
    Status s = new Status();
    s.setName("张三");
    s.setAge(2);

    Teacher t = new Teacher();
    t.setName("李四");
    t.setAge(3);

    register(s);
    register(t);
  }

  public static void register(Person p) {
    p.show();
  }
}
java
public class Person {
  private String name;
  private int age;

  public Person() {
  }

  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }

  ...
}
java
public class Student extends Person {
  @Override
  public void show() {
    System.out.println("学生信息为" + getName() + "," + getAge());
  }
}
java
public class Teacher extends Person{
  @Override
  public void show() {
    System.out.println("老师信息为" + getName() + "," + getAge());
  }
}

4. 包 ​

包就是文件夹，用来管理各种不同功能的Java类。

5. final 关键字 ​

说明
方法表明该方法是最终方法，不能被重写
类表明该类是最终类，不能被继承
变量叫做常量，只能被赋值一次
java
final int a = 10;
java
class FU {
  public final void show() {
    System.out.println("父类的show方法");
  }
}

class Zi extends FU {
  // 报错！！
  @Override
  public void show() {
    System.out.println("子类的show方法");
  }
}
java
final class FU {
  public void show() {
    System.out.println("父类的show方法");
  }
}

// 报错！！
class Zi extends FU { }

6. 权限修饰符 ​

有四种作用范围由小到大 （private < 空着不写 < protected < public）

可以在这里学习到它

说明同一个类中同一个包中其他类不同包下的子类不同包下的无关类
private私房自己用✔️❌❌❌
空着不写只能本包使用✔️✔️❌❌
protected受保护的✔️✔️✔️❌
public公共的✔️✔️✔️✔️

7. interface 接口 ​

在这里可以学习到它

java
public abstract class Animal {
  public abstract void eat();
}
java
public interface Swim {
  public abstract void swim();

  public default void method(){
    System.out.println("接口中的默认方法，不强制被重写");
  }
}
java
public class Frog extends Person implements Swim {

  @Override
  public void eat() { }

  @Override
  public void swim() { }
}

8. 抽象类和抽象方法 ​

抽象方法： 将共性的行为(方法)抽取到父类之后。由于每一个子类执行的内容是不一样，所以，在父类中不能确定具体的方法体。该方法就可以定义为抽象方法。

抽象类: 如果一个类中存在抽象方法，那么该类就必须声明为抽象类。

可以在这学习到它

抽象类和抽象方法的注意事项

  • 抽象类不能实例化
  • 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
  • 可以有构造方法
  • 抽象类的子类：要么重写抽象类中的所有抽象方法 / 要么是抽象类
java
// 抽象方法的定义格式
public abstract 返回值类型 方法名(参数列表);

// 抽象类的定义格式
public abstract class 类名 {}
java
public abstract class Person {
  public abstract void work();
}

9. 内部类 ​

内部类访问特点：1. 内部类可以直接访问外部类的成员，包括私有；2. 外部类要访问内部类的成员，必须创建对象

可以在这里学习到它

java
public class Car {
  String carName;
  String carColor;
  int carAge;
  
  class Engine {
    String engineName;
    int engineAge;
  }
}
  • 匿名内部类

小小棱镜，无限可能 | CC BY-NC-SA 4.0 协议

Copyright© 2023-2025 zeMing