封装、继承和多态

1.封装
(1)概念：隐藏类的实现细节，将属性私有化，提供公开的方法访问这些私有属性
(2)实现
①将属性私有化，使用关键字private修饰属性
②每一个私有属性提供两个方法，分别是getXxx和setXxx
(3)好处
①安全性：隐藏了属性，不让直接控制，可以通过方法来间接控制私有属性
②定制性：将所有属性都隐藏了，你可以对属性定制操作（比如给set方法或者get里面加if else 判断）
③打包性：将多个参数封装成了一个参数
2.继承
构造器没有继承
(1)概念：子类继承父类的一般特性（特征），以及自身的特有特性（特征）
(2)实现：
①书写父类，定义父类属性和方法
②书写子类，让子类通过关键字extends继承父类（一个子类只能继承一个父类）
(3)好处：
①可重用性
②传递性
③归类型
(4)注意：
①Java只支持单一继承
②Java中的所有类是直接或者间接继承于Object类
③产生子类时，优先产生父类，原则为 调用父类无参构造器，可以手动调用其他构造器
④产生的子类可以声明成父类类型，只能使用共有内容，一定要使用其他内容的话，必须强制类型转换
3.多态
(1)概念：一个事物具有多种形态的表现特征，就是多态。多态是面向对象的核心思想，多态分为方法的重写和重载。
(2)实现：
①重写：子类重写父类的方法，重写方法的实现（方法体）
重载：在一个类中，如果有多个方法，具有相同方法名，不同的形参列表（类型，顺序，个数）

package pro0703;
// 封装
public class DemoA {
    // 私有化属性 命名规范:首字母小写 驼峰
    private int id;
    private String name;
    private char sex;
    private int age;
    //每一个私有属性提供两个方法
    public int getId(){//获取到id的值,getXxx 返回类型是id的数据类型
        return id;
    }
    public void setId(int id){
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        if('男'==sex||'女'==sex){
            this.sex = sex;
        }else{
            this.sex = '男';
        }
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package pro0703;
// 继承
// 父类
public class DemoB1 {
    private int a = 3;
    public String b = "啊";
    private char c = '好';
    public double d = 8.9;

    public void a(){
        System.out.println("父类的a方法");
    }
    private void b(){
        System.out.println("父类的b方法");
    }
    public void c(){
        System.out.println("父类的c方法");
    }
}

package pro0703;
// 子类:DemoB2继承了DemoB1,那么DemoB2就继承下来了DemoB1的非私有属性和方法
public class DemoB2 extends DemoB1{
    //DemoB2类现在已经继承了两个属性两个方法

    // 以及自身的特有特性
    public int e = 90;
    public void d(){
        System.out.println("子类的d方法");
    }


    public static void main(String[] args) {
        DemoB2 db2 = new DemoB2();
        db2.a();//这个方法是父类写好的,子类继承下来了
        db2.c();
        db2.d();
        System.out.println(db2.b);
        System.out.println(db2.d);
        System.out.println(db2.e);
    }
}

package pro0703;
// 父类
public class DemoC1 {
    public void a(){
        System.out.println("父类的a方法");
    }
}

package pro0703;
// 子类
public class DemoC2 extends DemoC1{
    /*
    重写(Orerrides):子类重写父类的方法，重写父类方法的方法体
       1.子类和父类的方法结构一致
       2.方法体可以不一致
     */
     若想调用父类方法加super关键字
    super：当前类的父类对象
    super.方法名（）;
     */

    /*
    先父后子：要产生子类对象时，必须首先产生父类的对象
    默认情况下，产生父类对象调用无参构造器，也可以指定调用父类有参构造器

    要调用父类构造器
    可以用super关键字
    super();无参调用
    super（xxx）;有参调用，xxx为传入的参数
    注意：super（）调用时，必须写在第一行，遵守先父后子原则
     */
    public void a(){
        //super:当前类的父类对象
        super.a();//调用父类的a方法
        System.out.println("子类的a方法");
    }

    public static void main(String[] args) {
        DemoC2 dc2 = new DemoC2();
        // 调用子类的还是父类的？
        dc2.a();//子类的
    }
}
1. super用于显示调用父类的构造器，this用于显示调用本类中另一个重载的构造器； 
2. super 调用和this 调用都只能在构造器中使用，并且都必须作为构造器的第一行代码； 
3. super 调用和 this 调用最多只能使用其中之一， 而且最多只能调用一次。

package xzy0703;

public class DemoD1 {
    // 父类
        public DemoD1(){
            System.out.println("父类无参数的构造器");
        }
        public DemoD1(int i){
            System.out.println("父类有一个int参数的构造器");
        }
}

package xzy0703;

public class DemoD2 extends DemoD1{
    public DemoD2(){
        super(8);//必须写在第一行
        System.out.println("子类的无参数构造器");
    }
    public DemoD2(String a){
        System.out.println("子类有一个String参数的构造器");
    }

    public static void main(String[] args) {
        // 先父后子:要产生子类对象时,必须首先产生父类的对象；
        // 默认情况下,产生父类对象调用无参构造器,也可以指定调用父类有参构造器
        //匿名对象
        new DemoD2("aaa");
        //out：父类无参数的构造器
        //子类有一个String参数的构造器
    }
}

package xzy0703;
//一个.java文件中只能有一个public类
public class DemoE1 {
    public DemoE1(){
        System.out.println("父类无参构造器");
    };
    public DemoE1(int i){
        System.out.println("父类有参构造器");
    }
    public static void main(String[] args) {
        DemoE2 de2 = new DemoE2();
        //out:父类有参构造器
        //demoe2
    }
}
class DemoE2 extends DemoE1{
    public DemoE2(){
        super(3);
        System.out.println("demoe2");
    }

}

package xzy0703;

public class DemoF1 {
    private int a;
    public DemoF1(){ a = 3; }
    public DemoF1(int a){ this.a = a; }
    public void print(){ System.out.println(a); }
    public static void main(String[] args) {
        new DemoF2(8).print(); //先会调用父类的构造器，this指针指向当前父类，调用当前对象的方法
        //out：8
    }
}
class DemoF2 extends DemoF1{
    public int a = 5;
    public DemoF2(int a){
        this.a = a;
    }
    public void print(){
        System.out.println(a);
    }
}

package xzy0703;

public class DemoG1 {
    public void a(){
        System.out.println("父类的a");
    }
    public void b(){
        System.out.println("父类的b");
    }
    public static void main(String[] args) {
        DemoG1 dg1 = new DemoG1();
        DemoG2 dg2 = new DemoG2();
        // 只能使用共有属性和方法
        DemoG1 dg3 = new DemoG2();
        ((DemoG2) dg3).c();//强制类型转换
        //dg3.c（）报错
        dg2.a();//继承过来的方法
    }
}
class DemoG2 extends DemoG1{
    public void c(){
        System.out.println("子类的c");
    }
}

/*package xzy0703;


public class DemoE {
    public DemoE(int i){

    }
    public static void main(String[] args){
        DemoE2 de2 = new DemoE2();//在产生de2对象时，先产生父类DemoE对象，调用父类对应的构造器
    }
}
class DemoE2 extends DemoE{
    /*
    报错，因为在父类中，已经定义了一个带参构造器，所以父类中的默认构造器会失效，所以会报错
    解决方案：给父类添加一个无参构造器
     */

package xzy0703;
//继承 讲解Object类
public class DemoI {
    public static void main(String[] args) {
        DemoH dh = new DemoH();
        // 克隆一个新对象
        //Object obj = dh.clone();
        // 调用垃圾回收,清扫内容，回收对象
        //dh.finalize();
        String str = "";
        boolean b2 = str.equals(""); //比较两个字符串的值是否相等,String类将equals方法重写
        boolean b = dh.equals("");// 比较两个对象之间的地址是否相等
        // 获得到当前对象在内存中的地址(哈希值)
        int hashCode = dh.hashCode();
        // 获得当前对象的类型
        Class type = dh.getClass();
        // 将当前对象转换成字符串形式 当输出对象时,默认情况下输出对象的toString方法
        String s = dh.toString();
        System.out.println(dh);
        System.out.println(dh.toString());
    }
}

package xzy0703;
//方法的重载
public class DemoJ {
    public void a(){
        System.out.println("aaa");
    }
    public void a(int a){
        System.out.println("bbb");
    }
    public void a(String a){
        System.out.println("ccc");
    }
    public void a(int a,String b){
        System.out.println("ddd");
    }
    public void a(String a,int b){
        System.out.println("eee");
    }
    public static void main(String[] args) {
        /*System.out.println(7);
        System.out.println("aa");
        System.out.println('a');
        System.out.println(8.9);
        System.out.println(new DemoG1());*/
        DemoJ di = new DemoJ();
        di.a(3,"3");
    }
}