Java基础知识3

Java小结3

面向对象(OOP)

1、面向对象的本质就是：以类的方法组织代码，以对象封装数据。

2、面向对象的三大特性：

• 封装
• 继承
• 多态

3、类与对象的创建

Application.java

//程序唯一入口，定义唯一的main方法
public class Application {
    public static void main(String[] args) {
        Student student1 = new Student();
        Student student2 = new Student();

        student1.name = "小明";
        student1.age = 3;
        student2.name = "小红";
        student2.age = 3;

        student1.study();
        student2.study();
    }
}

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

    public void study(){
        System.out.println(this.name+"在学习");
    }
}

4、构造器

​ 构造器的特点：

• 和类名相同
• 没有返回值

​ 构造器的作用：

• new 的本质就是在调用构造器
• 初始化对象的值

Tips：类默认带无参构造，定义了有参构造之后一定要定义无参构造！(alt+insert 可以快捷添加构造器)

public class Person {

    String name ;
    int age;
    
    //无参构造
    public Person() {
    }

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

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

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

5、封装

封装的思想：高内聚，低耦合，我们禁止直接访问对象的数据，应该通过接口来访问！

核心：属性私有（private ），get/set方法

Tips：(alt+insert 可以快捷添加构造器)

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

    public int getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }
}

6、继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模！

//Person类，父类
public class Person {
    private int money;

    public void say(){
        System.out.println("hello");
    }
    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        this.money = money;
    }
}

//Student类，继承Person类
public class Student extends Person{
    
}

//Teacher类，继承Person类
public class Teacher extends Person{
    
}

//测试类，主函数入口
public class Application {
    public static void main(String[] args) {
        Student student = new Student();
        Teacher teacher = new Teacher();
        student.say();
        student.setMoney(100);
        teacher.say();
        teacher.setMoney(200);
        System.out.println(student.getMoney());
        System.out.println(teacher.getMoney());
    }
}

7、super关键字

• super调用父类的构造方法，必须在第一行
• super必须只能出现在子类的方法或者构造方法中
• super和this不能同时调用构造方法

Person.java
    
public class Person {
    //父类定义无参构造
    public Person() {
        System.out.println("Person无参执行了");
    }
    protected String name = "yh";

	//父类的print()方法
    public void print(){
        System.out.println("person");
    }
}

Studnet.java
    
public class Student extends Person{
    //子类定义无参构造
    public Student() {
        System.out.println("Student无参执行了");
    }
    private String name = "yh1";
	//子类的print()方法
    public void print(){
        System.out.println("Studnet");
    }
	//测试方法，super用来调用父类的方法，私有不能调用
    public void test(){
        print();
        this.print();
        super.print();
    }
}

Application.java

public class Application {
    //函数入口
    public static void main(String[] args) {
        Student student = new Student();
        student.test();
    }
}

8、方法重写

重写：需要有继承关系，子类重写父类的方法

• 方法名必须相同
• 参数列表必须相同
• 修饰符：可以扩大但不能缩小
• 抛出 的异常，范围可以缩小，但不能扩大

tips：静态方法才能被重写，非静态方法还是执行本身的方法

public class Person {
    public void test(){
        System.out.println("Person");
    }
}

public class Teacher extends Person{
    public void test(){
        System.out.println("Teacher");
    }
}

public class Application {
    public static void main(String[] args) {
        //定义子类和父类的对象
        Teacher teacher = new Teacher();
        Person person = new Teacher();
        //分别调用子类和父类的方法，发现都执行了子类的方法，父类的方法被重写了
        teacher.test();
        person.test();
    }
}

9、多态

• 多态是方法的多态，属性没有多态
• 存在条件：方法重写，继承关系，父类引用指向子类对象 Father father = new Son();

10、static关键字

• static修饰后的属性或者方法可以直接被调用
• 静态代码块会优先被执行，其次是匿名代码块，最后是构造方法

11、抽象类(abstract)

• 抽象类不能被new，只能靠子类去实现
• 抽象方法必须在抽象类中
• 抽象类中可以没有抽象方法，也可以写普通方法

12、接口(interface)

• 接口中的方法默认为public abstract的，即抽象的
• 接口中的常量默认为public static final，即静态常量(基本不这么用)
• 接口中的方法只是被定义，不能具体实现
• implements可以实现多个接口(接口多继承)