面向对象2——新手必看

一，封装

package oop.demo01;
//类   private：私有
public class Student {

    //属性私有
    private String name;
    private int id;
    private char sex;
    private int age;


    //提供一些可以操作这个属性的方法
    //提供一些public 的get，set方法

    //get  获得这个数据

    public  String getName(){
        return  this.name;
    }
    //set 给这个数据设置值
    public void setName(String name){
        this.name=name;

    }


    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public char getSex() {
        return sex;
    }

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

    public int getAge() {
        return age;
    }

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

    }
}
二，继承

package oop.demo02;
//学生  is  人，派生类，子类
//子类继承了父类，就会拥有父类的全部方法！
public class Student extends Person{

    public Student() {
        //隐藏代码，调用了父类的无参构造
        super();//调用父类的构造器,必须在子类构造器的第一行
        //父类没有无参构造，子类也不能写无参构造
        System.out.println("Student无参执行了");
    }

    private String name = "qinjiang";

    public void print(){
        System.out.println("student");
    }
    public void test1(){
        print();
        this.print();
        super.print();
    }
    public void test(String name){
        System.out.println(name);//秦疆
        System.out.println(this.name);//qinjiang
        System.out.println(super.name);//kuangshen

    }

}

三，方法重写

package oop.demo03;

import oop.demo03.A;
import oop.demo03.B;

public class Application {
    //静态的方法和非静态的方法区别很大
    //静态方法：方法的调用只和左边，定义的数据类型
    //非静态方法：重写！！！
    public static void main(String[] args) {
        //方法的调用只和左边，定义的数据类型有关
        A a = new A();
        a.test();//A


        //父类的引用指向了子类

        B b = new A();//子类重写了父类的方法
        b.test();//B
    }
}

四，什么是多态？

package oop.demo04;



public class Application {
    public static void main(String[] args) {
        //一个对象的实际类型是确定的
        new Person();


        new Student();
        //可以指向的引用类型就不确定了，父类的引用指向子类

        //Student  能调用的方法都是自己的或者继承父类的
        Student s1 = new Student();
        //Person父类型  可以指向子类，但不能调用子类独有的方法
        Person s2 = new Student();
        Object s3 = new Student();

        s2.run();//对象能执行哪些方法，主要看对象左边的类型，和右边关系不大
        s1.eat();//子类重写了父类的方法，执行子类的方法
    }
}