面向对象（一）

面向对象

类与对象的创建

public class Student {
    String name;
    int age;
    }            

public static void main(String[] args) {
        Student student1 = new Student();//调用类
        Student student2 = new Student();
        student1.name="小明";//给定义赋值
        student1.age=18;
    System.out.println(student1.name+"\n"+student1.age);//输出

输出结果

一个类即使什么都不写，它也会存在一个方法

显示的定义构造器

public class person {
    String name;
    public person(){
    }
}

输出null

public class person {
    String name;
    public person(){
        this.name="笨鸟";//this.name指String.name的name
    }
}

输出为菜鸟

构造器

1. 和类名相同
2. 无返回值

作用

1. 使用new关键字，本质上调用构造器
2. 用来初始化值

有了有参构造，如果想使用无参，无参构造就必须显示定义

快捷键：alt+Insert //快速建构造

无选择为无参构造，直接确定为有参构造

封装

public class person {
    //属性私有，private
    private String name;
    private int age;
    private char sex;
    //get 获得这个数据
    public int getAge() {
        return age;
    }
    //set 给这个数据赋值
    public void setAge(int age) {//赋值时可以加条件
        if(age>120||age<0){
            this.age=3;
        }
    }
    public String getName() {
        return this.name;
    }
    public void setName(String name){
        this.name=name;
    }
    }

封装的实现

import oop.person;

public class Student {
    public static void main(String[] args) {
       person student=new person();
        student.setName("笨鸟");
        System.out.println(student.getName());
        student.setAge(133);
        System.out.println(student.getAge());
    }
}

封装的作用：

1. 提高程序的安全性，保护数据
2. 隐藏代码的实现细节
3. 统一接口
4. 系统可维护增加了

继承

public class father {  //创建一个基类（也称父类）
    public int money=10000000;
public void say(){
        System.out.println("说了一句话");
    }
}

//再创建一个派生类（也称子类）

public class son extends father{//entends继承父类
}

import oop.demo03.son;

public class person {
    public static void main(String[] args) {
        son person=new son();//new创建实例
        person.say();//子类继承父类所有方法
        System.out.println(person.money);
    }
}

java中只有单继承，没有多继承

拓展：Ctrl+H，查看继承树。//java所有类，都默认直接或间接继承Object

super

public class father {  //父类
    public String name="benniao";
}

public class son extends father{  //子类
    private String name="笨鸟";
    public void test(String name){
        System.out.println(name);//BN 调用的是public void test(String name)可以赋值的形参
        System.out.println(this.name);//笨鸟 调用的是本身函数的name
        System.out.println(super.name);//benniao 调用的是父类的name
    }
}

import oop.demo03.son;

public class person {
    public static void main(String[] args) {
        son person=new son();
        person.test("BN");
    }
}

super注意点：

1. super调用父类的构造方法，必须在构造方法的第一个。
2. super必须只能出现在子类的方法或者构造方法中！
3. super和this不能同时调用构造方法！

与this的区别:

1. 代表的对象不同：
   this: 本身调用者这个对象。
   super: 代表父类对象的应用。
2. 前提：
   this: 没有继承也可以使用。
   super: 只能在继承条件下才可以使用。
3. 构造方法：
   this(); 本类的构造。
   super(); 父类的构造。