Java 类与对象

类与对象

• 用来描述客观事物的一个实体，由一组属性和方法构成
• 属性：对象具有的各种特征 每个对象的每个属性都有特定值
• 方法：对象执行的操作
• 类是对象概括、对象的分类，是具有相同方法和属性的一组对象的集合，描述对象拥有的特征和行为

定义类

使用[访问控制符] class 类名定义类

public class Person {
    // 用[访问控制符] 数据类型 变量名 定义属性
    String name;
    public int age;

    // 用 [访问控制符] 返回值类型 方法名 定义方法
    public void sleep() {
        System.out.println("睡觉");
    }
}

构造函数

用于初始化对象
在类中以[访问控制符] 类名(参数列表) { 方法体 }形式的方法为类的构造函数
如果一个类没有构造函数，则会自动生成一个无参构造函数
使用new 构造函数()创建对象

class Person{
    public int age;

    public Person(){
        System.out.println("hello");
        age = 21;
    }
    // 一个类中可以有多个构造函数，它们的参数列表不同
    public Person(int age) {
        this.age = age;
    }

    public static void main(String[] args){
      Person p = new Person(); // hello
      System.out.println(p.age); // 21
    }
}

方法

用来定义类的行为
[访问修饰符] 返回值类型 类名(参数列表) {方法体}
- 如果方法有返回值，需要return相应类型的值
- 如果方法无返回值，返回值类型为void
- 调用方法为对象名.方法名()

class Method{
    public int method(int a) {
        return a;
    }

    public static void main(String[] args){
      Method m = new Method();
      m.method(123);
    }
}

重载

方法名相同，参数列表不同的两个或多个方法

class Method{
    int method(int a) {
        return a;
    }

    int method() {
        return 123;
    }

    public static void main(String[] args){
      Method m = new Method();
      m.method(123);
      m.method();
    }
}

面向对象编程

封装

将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问
增加了代码的安全性

用private将类的成员声明为私有的
在类的外部无法直接访问私有成员，可以通过方法间接访问

class Person {
    private int age;

    public void setAge(int age) {
        this.age = age;
    }
}

public class Test {
    public static void main(String[] args) {
      Person p = new Person();
      p.age = 12; // error
      p.setAge(12); 
    }
}

继承

使用extends继承
子类拥有父类的属性和方法
子类使用super访问父类protected以上级别的成员

class Parent {
    public void method() {
    }
}

class Child extends Parent {
    void meth() {
        super.method();
    }
}

public class Test{
    public static void main(String[] args){
      Child c = new Child();
      c.method();
    }
}

访问修饰符

• private 仅在本类中可访问
• 默认 在同包中可访问
• protected 子类可访问
• public 随处可访问

重写

子类中与父类拥有相同方法名，返回值，参数类型的方法
访问修饰符不能比父类更严格
不能重写构造函数

class Parent {
    public void method() {
        System.out.println("aaa");
    }
}

class Child extends Parent {
    public void method() {
        System.out.println("bbb");
    }
}

public class Test{
    public static void main(String[] args){
      Child c = new Child();
      c.method(); // bbb
    }
}

抽象

使用abstract修饰符使类和方法变为抽象的
抽象类不能实例化，只能被继承
抽象方法只能存在于抽象类中
抽象方法没有方法体，子类必须实现该方法，除非子类也是抽象类

abstract class Animal{
    abstract void play();
}

class Dog extends Animal{
    void play(){

    }
}

public class Test{
    public static void main(String[] args){
        Animal a = new Animal(); // error  
        Dog d = new Dog();
    }
}

常量

使用final修饰符声明常量类和常量成员
final修饰的类不能被继承，方法不能被重写，变量不能被修改

final class FinalClass{
    final int a;
    final void method() {}
}

class Child extends FinalClass { // error
    void method() {} //error
} 

public class Test{
    public static void main(String[] args){
        final int a = 1;
        a = 2; // error
    }
}

静态

使用static声明一个静态方法或属性
类的所有实例共用同一个静态属性
static成员可以直接通过类名.成员名访问而无需实例化

public class Test{
    static int a = 1;
    public static void main(String[] args){
      Test t1 = new Test();
      Test t2 = new Test();
      System.out.println(t1.a); // 1
      System.out.println(t2.a); // 1
      System.out.println(Test.a); // 1
      t1.a++;
      System.out.println(Test.a); // 2
    }
}

接口

使用interface定义接口
接口中的方法默认为public abstract的
接口不可直接实例化
一个类只能继承一个类，但能实现多个接口
使用implements实现接口，多个接口间用逗号隔开
接口中的属性全是public static final的
实现类必须实现接口的所有方法，除非实现类是抽象的
接口可以实现其他接口

public interface Intfc{
    void method1();
    int sta = 10;
    // java8允许为接口的方法定义默认实现
    default void method2(){

    }
}

class IntfcClass implements Intfc{
    void method1(){}
}