Java-封装、继承、多态

封装

面向对象中的封装：封装可以提高安全性，把属性和方法封装到一个类型，属性使用private修饰，提高属性的安全性。
封装使用方便，把属性使用private修饰，方法用public修饰，当访问私有的属性（private修饰属性），可以通过该类中公有的方法来访问（public修饰的方法）

public class Test1 {
    public static void main(String[] args) {
        User user=new User();
//        user.name="关羽";//错误
        user.setName("关羽");
    }
}
class User{
    //通过一个类，把属性和方法封装到了一起，属性使用private修饰，方法用public修饰，外界不能直接访问该属性，但可以通过公有方法来间接访问私有属性
    private String name;
    public void setName(String name){
        this.name=name;
    }
}

javaBean

是企业开发的一种约定俗成的习惯，不是具体的语法概念，用来保存数据。
javaBean要求：
1)    属性私有（使用private修饰属性）
2)    必须有public修饰的get/set方法来访问私有的属性
3)    构造方法必须有，而且要有一个空参的构造方法
目的：操作数据，使用方便

public class Test1 {
    public static void main(String[] args) {
        Person person=new Person();
        person.setName("刘诗诗");
        person.setAddress("中国");
        person.setAge(29);
        person.setPhone("12355566666");
        System.out.println(person.getName());
        System.out.println(person.getAddress());
        System.out.println(person.getAge());
        System.out.println(person.getPhone());
    }
}
class Person{
    private String cardNo;//私有的属性
    private String name;
    private String phone;
    private int age;
    private double salary;
    private String address;
    public Person(){}//空参的构造方法
    //针对私有属性，有get/set方法来访问
    public String getCardNo() {
        return cardNo;
    }
    public void setCardNo(String cardNo) {
        this.cardNo = cardNo;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public double getSalary() {
        return salary;
    }
    public void setSalary(double salary) {
        this.salary = salary;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
}

继承

1)复用：开发只需要定义独有的功能（属性和方法），再复用曾经写过的功能（属性和方法）
2)extends：继承的关键字
格式：class 子类 extends 父类
3)子类可以继承父类的方法和属性
4)继承本质：把父类的属性和方法代码拷贝到子类中，再写子类代码时候，可以减少代码量，只需要添加新的部分
5)java中的继承单继承：子类只能有一个直接的父类，但是层层继承

public class Test1 {
    public static void main(String[] args) {
        Student student=new Student();
        //name,age,sex这三个属性，Student这个类从父类Person2中继承过来
        student.name="刘英谦";
        student.age=18;
        student.sex="男";
        student.address="哈尔滨";
        student.score=100;
        student.speak();
        student.add(12, 23);
        
        Teacher teacher=new Teacher();
        teacher.name="孔祥燕";
        teacher.age=18;
        teacher.sex="女";
        teacher.salary=5000;
        teacher.speak();
        teacher.teach();
    }
}
//设计一个Person类，属性：姓名，性别，年龄
//暂时不要写任何的构造方法，方法：说话的行为
//设计一个Student类，属性：姓名，性别，年龄，分数，地址
//暂时不要写任何的构造方法，方法：说话的行为，加法运算
//设计一个Teacher类型，属性：姓名，性别，年龄，工资
//暂时不要写任何的构造方法，方法：说话的行为，讲课
class Person2{//父类
    String name;
    int age;
    String sex;
    void speak(){
        System.out.println("我是："+name);
    }
}
class Student extends Person2{//子类
    int score;
    String address;
    void add(int num1,int num2){
        int sum=num1+num2;
        System.out.println(sum);
    }    
}
class Teacher extends Person2{//子类
    double salary;
    void teach(){
        System.out.println("讲课");
    }
}

public class Test1 {
    public static void main(String[] args) {
        Foo4 foo4=new Foo4();
        System.out.println("f1="+foo4.f1);
        System.out.println("f2="+foo4.f2);
        System.out.println("f3="+foo4.f3);
        System.out.println("f4="+foo4.f4);
    }
}
class Foo1{
    int f1=1;
}
class Foo2 extends Foo1{
    int f2=2;
}
class Foo3 extends Foo2{
    int f3=3;
}
class Foo4 extends Foo3{
    int f4=4;
}

继承中的构造方法的使用

1)子类不能继承父类的构造方法，子类会默认的调用父类的构造方法（父类中没有无参的构造）
2)父类中有无参的构造方法，子类可以任意设计自己构造方法

public class Test1 {
    //父类中有空参的构造方法，则子类可以任意的创建自己的构造方法
    public static void main(String[] args) {
        Emp2 emp=new Emp2("刘",23);
        emp.show();
        Emp2 emp1=new Emp2("王",37,30000.0);
        emp1.show();
        System.out.println(emp1.salary);
    }
}
class Emp1{
    String name;
    int age;
    //默认提供空参的构造方法
    void show(){
        System.out.println(name+","+age);
    }
}
class Emp2 extends Emp1{
    double salary;
    //父类有空参的构造方法，子类任意设计自己的构造方法
    Emp2(String name,int age,double salary){
        this.name=name;
        this.age=age;
        this.salary=salary;
    }
    Emp2(String name,int age){
        this.name=name;
        this.age=age;
    }
}

父类中没有空参的构造方法，则子类的构造方法必须要调用父类中带参数的构造方法
super：过去的，曾经的
super（参数）：写在子类构造方法的第一行，调用父类中的构造方法

public class Test1 {
    public static void main(String[] args) {
        User2 user=new User2("张","123456",20);
        System.out.println(user.name);
        System.out.println(user.password);
        System.out.println(user.age);
    }
}
class User1{
    String name;
    String password;
    //父类中构造方法带参数
    User1(String name,String password){
        this.name=name;
        this.password=password;
    }
}
class User2 extends User1{
//父类中只有带参数的构造方法的时候，子类就会默认的去调用父类的构造方法
//利用super来调用父类的构造方法
//企业开发中，父类最好都写一个不带参数的构造方法，这样子类可以任意去创建自己的构造方法
    int age;
    User2(String name,String password,int age){
        super(name,password);//super（参数）：根据参数去调用父类中的构造方法，而且super必须写在第一行
        this.age=age;
    }
}

public class Test1 {
    //企业开发一般建议，设计类的时候，都添加一个空参的构造方法，这样其他程序根据父类，可以任意的设计自己的子类的构造方法
    public static void main(String[] args) {
        Koo2 koo2=new Koo2("刘",23,"广州");
        System.out.println(koo2.name+","+koo2.age+","+koo2.address);
    }
}
class Koo1{
    String name;
    int age;
    Koo1(String name,int age){
        this.name=name;
        this.age=age;
    }
    //给父类添加一个空参的构造方法
    Koo1(){}    
}
class Koo2 extends Koo1{
    String address;
    Koo2(String name,int age,String address){
        this.name=name;
        this.age=age;
        this.address=address;
    }
}

多态

对象的多种形态
1.引用多态
父类的引用可以指向本类的对象
父类的引用可以指向子类的对象

2.方法多态
创建本类对象时，调用的方法为本类方法
创建子类对象时，调用的方法为子类重写的方法或者继承的方法