Java学习，面向对象中的封装与继承与多态

封装

在类中，有着方法和属性，都可以供给其他类去调用，方法是功能的实现，调用后不会有什么问题，但是属性是属于类和对象的，太容易被篡改，这样的属性太过于不安全，会导致程序出现很大的安全问题
为了保护属性的安全，所以有人提出了封装的概念，即用private对属性进行私有化，那么在其他的类中这些属性就不可被修改调用，但这样就不能对属性进行赋值，所以就出现了get，set方法，使用它们可以进行间接的修改和访问
封装的出现，提高了软件的可重用性，并且降低了构建大型系统的风险

//例如
public class Hello {
    private int a;//private对属性进行封装

    public int getA() {//调用成员属性a
        return a;
    }

    public void setA(int a) {//使用此方法为a赋值
        this.a = a;//this指得是调用这个方法的对象
    }
}

快捷构造get和set方法;
alt+insert 会出现如下选项

修饰符，关键字

修饰符：
public：对外公开，都可以访问
protected：受保护，对同一个包下和子类中可以访问
默认修饰符：同一个包下可以访问，子类中不行
private：只在当前类中有效
关键字
static：使用此关键字的，则表明是类范围的从属于类，可以修饰成员属性、方法和代码块
this：代表当前对象

继承

即创建的子类对象可以使用父类中的属性和方法；
子类和父类使用extends进行连接；
一个子类只能有一个父类，但是父类却可以拥有多个子类，通常，父类是抽取多个子类相同的属性和方法形成的：具体写法如下

// 父类，以及父类的属性与方法
public class Fu {
    private int fu;
    public int getFu() {
        return fu;
    }
    public void setFu(int fu) {
        this.fu = fu;
    }
}

// 子类，以及其中的属性与方法，并且在子类的声明方法上用extends和父类相连接
public class Zi extends Fu{
    private String zi;
    public String getZi() {
        return zi;
    }
    public void setZi(String zi) {
        this.zi = zi;
    }
}

// 在测试 类中创建子类对象
    public static void main(String[] args) {
        Zi zi = new Zi();
        zi.setZi("子类");
        zi.setFu(12);//创建的子类对象可以调用父类的方法，对父类属性赋值
        zi.getZi();
        zi.getFu();
    }

关键字

关键字：this、super
本类成员和局部变量重名使用this区分
本类成员和父类成员重名使用super区分
形如：
this.a指得是当前对象的成员a
super.a指得是父类中的成员a

重写（覆盖）和重载

重载

重载：指在同一个类中方法名相同但是形参不同，最典型的即为有参构造与无参构造

// An highlighted block
public class Zi {
    private String zi;
    public Zi() {//无参构造
    }
    public Zi(String zi) {//有参构造
        this.zi = zi;
    }
}

// 有参构造和无参构造都可以使用，只是用是否加入参数来区分
    public static void main(String[] args) {
        Zi zi = new Zi();//无参构造
        Zi zi1 = new Zi("子类对象");//有参构造
    }

重写

重写：子类和父类同名的方法；
子类方法和父类方法同名，子类方法会覆盖父类方法，称为重写（覆盖），前提，子类方法访问权限必须大于或等于父类方法的访问权限
并且在子类中被重写的方法必须是方法名，返回值类型以及形参数量及种类都相同

//父类
public class Fu {
    public void fun(){
        System.out.println(132546);
    }
}

//子类
public class Zi extends Fu{
    @Override//代表是重写方法
    public void fun() {//方法名、返回值、参数都相同
        super.fun();//这是调用父类中原有的方法，视情况可要可不要
        System.out.println(7894651);//子类对父类的重写或添加
    }
}

多态

把子类的实例化对象赋值给父类的引用类型
可以认为：多态=继承+重写
具体为：

// 父类
public class Fu {
    public void fun(){//父类中的方法
        System.out.println("父类中的方法");
    }
}

// 第一个子类
public class Zi1 extends Fu{
    @Override
    public void fun() {//第一个子类对父类方法的重写
        super.fun();
        System.out.println("第一个子类重写的方法");
    }
}

// 第二个子类
public class Zi2 extends Fu {
    @Override
    public void fun() {//第二个子类对父类方法的重写
        System.out.println("第二个子类中重写的方法");
    }
}

// 测试类
public class Test1 {
    public static void main(String[] args) {
        Fu zi = new Zi1();//将子类对象赋值给父类的引用类型
        Fu zi2 = new Zi2();
        zi.fun();//调用重写的方法
        zi2.fun();
    }
}

多态针对的是子类中被父类重写的方法，如果把子类的实例化对象赋值给父类的引用类型则无法调用子类中的独有方法