面向对象

面向对象

创建与初始化对象

Student类

package com.oop.Demo01;

//学生类
public class Student {
    //属性：字段
    String name;
    int age;
    //方法
    public void study(){
        System.out.println(this.name+"在学习");
    }
}

然后在主方法Application中调用

package com.oop.Demo01;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {

        //类，抽象的，调用必须实例化；
        //类实例化后会返回一个自己的对象；
        //Student对象就是一个Student类的具体实例化；
        Student xh = new Student();
        Student xm = new Student();

        xh.age = 10;//不赋值的情况下，默认为0；
        xm.age = 10;
        xh.name = "小红";//不赋值的情况下，默认为null；
        xm.name = "小明";

        System.out.println(xh.name);
        System.out.println(xh.age);
        xh.study();
        xm.study();
    }
}

运行结果：

类中的构造器（构造方法）

Person类

package com.oop.Demo01;
/*
总结:
构造器：
1、和类名相同；
2、没有返回值；
作用：
1、new的本质在调用构造方法；
2、初始化对象的值；
注意点：
1、定义有参构造器之后，如果想使用无参构造，必须手动显示定义一个无参的构造
2、Alt+insert可以快捷构建各种构造器；
 */
public class Person {
    //构造器
    //一个类即使什么也不写，它也会存在一个方法
    //显示的定义构造器
    String name ;
    int age;
    //有参的构造器String name
    public Person(String name) {
        this.name = name;
    }
    //无参的构造器
    public Person() {
    }
    //有参的构造器int age
    public Person(int age) {
        this.age = age;
    }
    //有参的构造器String name, int age
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Application

package com.oop.Demo01;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        Person person1 = new Person();//调用无参的构造器；
        Person person2 = new Person("小明");//调用有参的构造器String name；
        Person person3 = new Person(12);//调用有参的构造器int age；
        Person person4 = new Person("小红",13);//调用有参的构造器String name, int age；
        System.out.println("调用无参的构造器："+person1.age);
        System.out.println("调用有参的构造器String:"+person2.name);
        System.out.println("调用有参的构造器int age:"+person3.age);
        System.out.println("调用有参的构造器String name, int age："+person4.name);
        System.out.println("调用有参的构造器String name, int age："+person4.age);

    }
}

运行结果：

封装：Encapsulation

Encapsulation类

package com.oop.Demo01;

public class Encapsulation {
    //封装：Encapsulation
    //设置私有属性；
    private String name;
    private int age;
    private char sex;
    //Alt + insert 快速生成属性的get和set方法；
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        if (age < 120 || age > 0) {
            this.age = age;
        } else
            this.age = 3;
    }

    public char getSex() {
        return sex;
    }

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

Application

package com.oop;

import com.oop.Demo01.Encapsulation;
import com.oop.Demo01.Person;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        Encapsulation el = new Encapsulation();
        el.setAge(99);
        el.setName("王华");
        System.out.println(el.getAge());
        System.out.println(el.getName());
    }
}

运行结果：

继承

代码演示：

Son 01类（子类）

package com.oop.Demo02;

//子类
public class Son01 extends Father {

    //Ctrl+H 可以看到继承树。
    public String name = "程儿子";

    public Son01() {
        //隐藏的代码：调用了父类的无参构造器
        super();//调用父类的构造器，必须要在子类的第一行；
        System.out.println("儿子的无参构造器");
    }

    public void print(String name) {
        System.out.println(name);
        System.out.println(this.name);
        System.out.println(super.getName());
    }

    public void say() {
        System.out.println("程儿子会说话！");
    }

    public void test() {
        say();
        this.say();
        super.say();
    }
}

Father类（父类）

package com.oop.Demo02;

//父类
//在java中所有的类都默认或者间接继承object
public class Father {

    /*
    四个优先级修饰符
    public > protected > default > private
     */
    private String name = "程父亲";
    private int moner = 1000000;

    public Father() {
        System.out.println("父亲的无参构造器");
    }

    //私有的东西无法被继承
    public void say() {
        System.out.println("程父亲会说话！");
    }

    public String getName() {
        return name;
    }

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

    public int getMoner() {
        return moner;
    }

    public void setMoner(int moner) {
        this.moner = moner;
    }
}

Application类（启动）

package com.oop;

import com.oop.Demo01.Encapsulation;
import com.oop.Demo01.Person;
import com.oop.Demo02.Son01;

//一个项目应该只存在一个main方法
public class Application {
    public static void main(String[] args) {
        Son01 son = new Son01();//new一个新的对象（子类）son；
        son.say();//子类调用了父类的方法;
        System.out.println(son.getMoner());//调用父类封装的属性；
        //测试this和super
        son.print("孙中山");
        son.test();
    }
}

运行结果：

小结

super注意点：
    1. super调用父类的构造方法，必须在构造方法的第一个；
    2. super必须只能出现在子类的方法或者构造方法中；
    3. super和this不能同时调用构造方法；
Vs this：
    代表对象不同：
       this：本身调用者这个对象；
       super：代表父类对象的应用；
前提：
    this：没有继承也可以使用；
    super:只能在继承的条件下才可以使用；
构造方法:
    this():本类的构造；
    super()：父类的构造；

方法的重写

代码的演示

A(父类)

package com.oop.Override;
//父类
public class A {
    public static void test1(){
        System.out.println("A");
    }
    public void test2(){
        System.out.println("AA");
    }
}

B(子类）

package com.oop.Override;
//子类
public class B extends A{
    public static void test1(){
        System.out.println("B");
    }
    public  void test2(){
        System.out.println("BB");
    }
}

运行结果

小结

重写：需要继承关系，子类重写父类的方法！
    1. 方法名必须相同；
    2. 参数列表必须相同；
    3. 修饰符;范围可以扩大但不能缩小；public > Protected > Default > private;

重写：子类的方法和父类的方法一致，但方法体不同；

为什么需要重写？
    1. 父类的功能，子类不一定需要，或者不一定满足！
    重写快捷键：Alt+Insert——>override;