Java学习（五）：面向对象

简单类的初始化

public class Person {

    String name;

    //一个类即使什么都不写，也会存在一个方法
    //显示的定义构造器
    //new的本质就是在调用构造器
    public Person(){}

    //有参构造
    public Person(String name){
        this.name = name;
    }

}

• 定义构造器的快捷键：alt + insert
• this指示当前类

private 私有

public class Student {
    private String name;
    private int age;
    private char sex;

	//以下通过alt + insert快捷键即可生成
    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;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}
//---------------------------------------------------------
//主函数
public class Appliicatiion {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("zq");
        System.out.println(student.getName());

    }
}

继承 extends

• ctrl + h：查看类的继承关系

• super：访问父类的属性和方法

• private无法调用

• 子类中默认调用父类的构造器 super()

• super和this不能同时调用构造方法

public class B {
   public static void test(){
       System.out.println("B => test()");
   }
}


public class A extends B {
   public static void test(){
       System.out.println("A => test()");
   }
}


public class Appliicatiion {
   public static void main(String[] args) {
      //方法的调用只和左边定义的数据类型有关
       A a = new A();
       a.test();  // A => test()

       //父类的引用指向了子类
       B b = new A();
       b.test();  // B => test()

   }
}

方法重写

public class B {
    public void test(){
        System.out.println("B => test()");
    }
}


public class A extends B {
    //重写（不加static），通过alt+insert快捷生成，可以不加注释
    @Override //注解，有功能的注释
    public void test() {
        //super.test();
        System.out.println("A => test()");
    }
}


public class Appliicatiion {
    public static void main(String[] args) {
       //方法的调用只和左边定义的数据类型有关
        A a = new A();
        a.test();  // A => test()

        //父类的引用指向了子类
        B b = new A();
        b.test();  // A => test()

    }
}

instanceof

X instanceof Y  //能不能编译通过，取决于X和Y之间存不存在父子关系

static静态代码块

public class Person {
    {
        System.out.println("匿名代码块");
    }
    
    //只执行一次
    static {
        System.out.println("静态代码块");
    }

    public Person(){
        System.out.println("构造方法");
    }

    public static void main(String[] args) {
        Person p = new Person();
        //输出：静态代码块
        //     匿名代码块
        //     构造方法
        //注意执行顺序：静态代码块、匿名代码块、构造方法
    }
}

静态导入包

import static java.lang.Math.random;
//可以直接通过random()使用

抽象 abstract

父类中，抽象类中的抽象方法可以仅定义不实现，继承了它的子类必须重写抽象方法。
抽象类不能new，只能通过子类实现。

接口 interface

• 普通类：只有具体实现
• 抽象类：具体实现和规范（抽象方法）都有
• 接口：只有规范，自己无法写方法~专业的约束！ 约束和实现分离：面向接口编程

//接口都需要实现类
public interface UserService {
    //接口可以定义常量，默认public static final
    int AGE=99;
    
    //接口中的定义其实都是抽象的，省略了public abstract
    void run(String name);
}


public interface TimeService {
    void timer();
}


//类可以实现接口
//实现了接口的类，就需要重写接口中的方法
//利用接口可以实现多继承
public class UserServiceImpl implements UserService, TimeService {
    @Override
    public void run(String name) {

    }

    @Override
    public void timer() {

    }
}

内部类