Java封装和继承

1、封装

封装：隐藏对象的属性和实现细节，仅对外公开接口（方法/函数），控制在程序中属性的读和修改的访问级别

Java中的封装：

1）广义上：一切公共的代码的抽取都可以叫做封装。一般体现在公共方法的封装。工具类。

2）狭义上：隐藏对象的属性和实现细节。①将属性私有化，使用private关键字修饰。②为使用private关键字修饰的属性添加getter和setter方法。通过get和set方法来操作属性。③在setter方法中，添加数据的逻辑校验。

public class Student {
    //设置属性私有化
    private String name;
    private int age;
    //构造方法
    public Student(){}
    public Student(String name,int age){
        setName(name);
        setAge(age);
    }
    public void show(){
        System.out.println("姓名:"+this.name+"\t年龄:"+this.age);
    }
    //getter和setter方法
    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 > 0 && age <= 120){
            this.age = age;
        }else {
            System.out.println("年龄无效");
        }
    }
}

student.setName("张三");
student.setAge("19");
System.out.println(student.getName());
System.out.println(student.getAge());

封装的作用：保护属性的有效性。

2、继承

继承（inheritance）是面向对象软件技术中的一个概念，和多态、封装共称为面向对象的三个基本特征。继承可以使子类具有父类的非私有的属性和方法，或者可以重新定义、追加属性和方法。这种技术可以复用以前的代码，缩短开发周期，降低开发费用。

类B"继承"类A：

B称为：A的子类或派生类（subclass）；

A称为：B的父类或超类或基类（superclass）。

继承的作用：①提高代码的可重用性；②能够扩展功能；③方便维护；

继承的特点：Java中类与类之间是单继承的，但是可以多级继承。一个父类可以有多个子类。

继承的语法格式：

[权限修饰符] class 子类名 extends 父类名{}


//定义父类
public class Fu {
    int money = 500;
    public void house(){
        System.out.println("老房子");
    }
}

//定义子类
public class Zi extends Fu{
    //重写方法的注解
    @Override
    public void house() {
        System.out.print("先住父亲的");
        //调用父类的方法
        super.house();
        System.out.println("然后住了自己买的小洋房");
    }
}

//测试方法
public class Test1 {
    public static void main(String[] args) {
        Zi zi = new Zi();
        System.out.println(zi.money);
        zi.house();
    }
}

//运行结果
500
先住父亲的老房子
然后住了自己买的小洋房

3、方法重写@Override注解

方法重写：子类继承父类中的方法时，不想原封不动地继承父类的方法，需要做一些修改，需要采用方法重写。方法重写又称为方法覆盖

方法重写和方法重载的区别：

重载（overload）：发生在同一个类中，方法名相同，参数列表不同，不考虑返回值。

重写（overrides）：①发生在父子类中，子类继承父类的方法，方法名相同，参数也相同，方法体不同。②子类的返回值必须小于等于父类的返回值范围。③子类方法的权限必须要大于等于父类方法的权限（不包括private）。④子类重写方法异常声明必须时父类的异常或者是子级异常。⑤私有的属性和方法不能被继承。

注：任何类都是object类的直接子类或者间接子类

例子：上面的house()方法就是一个方法重写的案例。

toString()方法重写

toString()方法重写前：

public class TestStu {
    public static void main(String[] args) {
        int num = 12;
        String str = "xxx";
        Student student = new Student("张三",34);
        System.out.println(num);
        System.out.println(str);
        System.out.println(student);
    }
}

//输出结果
12
xxx
com.qy151.test1.testjicheng.Student@4554617c

toString()方法重写，以及重写后的输出结果：

@Override
public String toString() {
    return this.name+" "+this.age;
}


//输出结果
12
xxx
张三 34

4、super关键字(父类对象)，this关键字（当前对象）

如果子类既想使用父类的成员变量和成员方法，又想使用自己的方法，需要通过super关键字。

super关键字的用法：

①在子类的成员方法中访问父类的成员变量和方法。super.成员方法名();

②在子类的构造方法中访问父类的构造方法。子类的构造方法参数列表写全，构造方法中用super(参数列表);调用父类的构造方法。

5、继承中构造方法的特点

①构造方法不能被继承（方法名不同，不能构成继承关系）。

②创建子类对象一定是先调用父类构造，再调用子类构造，先有父，后有子，并且只有子类构造才能调用父类构造。父类没有无参构造，只有有参构造的时候，我们需要在子类构造的第一行代码处，显示调用父类构造。

③子类构造可以通过super关键字调用父类的构造方法。无参super()   有参super(参数列表)。

④super父类构造调用，必须是子类构造中的第一行语句。

6、Object类

Object类是所有类的父类，任何类都默认继承Object，因此省略了extends Object 关键字。该类主要有以下方法：toString(), getClass(), equals(), clone(), finalize(), 其中toString(), getClass(), equals()是最重要的方法。

其中，getClass(), notify(), notifyAll(),wait()等方法被定义为final类型，因此不能重写。

equals() 方法在比较字符串时是比较的两个字符串的值。实际上在Object包中equals() 方法是比较的地址值。

String可以用equals()比较值是因为String类中重写了equals() 方法

public boolean equals(Object anObject) {
    //如果两个对象中存储的值（地址）相同，就返回true
    if (this == anObject) {
        return true;
    }
    //如果作比较的对象是字符串类型，就逐个比较
    if (anObject instanceof String) {
        String anotherString = (String)anObject;
        //当前字符串的长度
        int n = value.length;
        //比较两个字符串的长度
        if (n == anotherString.value.length) {
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            //字符串不为空，比较字符
            while (n-- != 0) {
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            return true;
        }
    }
    return false;
}

7、final关键字

三种用法：

1）用来修饰类：final修饰的类不能被继承，也就意味着这个类中的方法不能被重写；

2）用来修饰方法：final修饰的方法不能被覆盖和重写，表示是一个最终的方法；

3）用来修饰变量：final修饰成员变量，就变成了常量，命名必须全大写，多个单词使用下划线连接；

基本数据类型：使用final修饰的基本数据类型值不能变，并且只能被赋值一次。

引用数据类型：使用final修饰的引用数据类型，引用的地址值不会变，但是对象的属性值可以改变。

• 对于成员变量，使用final修饰变量也是不可变的，成员变量有默认值，所以必须要手动赋值；
• 对于final修饰的成员变量，可以直接赋值，也可以在构造方法中赋值，但是必须二选一；
• 如果使用构造方法赋值，并且类中有多个构造方法，必须保证每一个构造方法都要对final修饰的成员变量赋值。

8、基本类型（四类八种包装类）

基本数据类型对应的包装类：

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

自动装箱和自动拆箱：

装箱：基本数据类型转换成包装类

拆箱：包装类转换成基本数据类型

使用：

1）基本数据类型（int）转为字符串（String）

• 使用数字加空字符串： String a = 5+"";
• 使用Integer包装类的方法 toString(int i)：String a = Integer.toString(100);
• 使用String类的valueOf(int i)：String a = String.valueOf(100);

2）字符串（String）转为基本数据类型（int）

• int a = Integer.parseInt("100");只有数字类型的字符串才可以转换成数字。

public class TestInt {
    public static void main(String[] args) {
        int a = 12;
        Integer b = 24;
        //拆箱
        a = b;
        //装箱
        b = a;
        System.out.println("a:"+a);//a:24
        System.out.println("b:"+b);//b:24
        //整型的最大值
        System.out.println(Integer.MAX_VALUE);//2147483647
        //整型的最小值
        System.out.println(Integer.MIN_VALUE);//-2147483648
        //整型转为字符串
        String str = Integer.toString(100);
        //字符串转为整型
        int c = Integer.valueOf("123");
        int d = Integer.parseInt("234");
        //去除两个数中的最大值
        System.out.println(Integer.max(12,56));//56
        //对象类型可以为null
        Integer e = null;
        //基本数据类型不能为null
        //int f = null;
    }
}

public class TestDouble {
    public static void main(String[] args) {
        double a = 1.23;
        Double b = 2.34;
        //拆箱
        a = b;
        //装箱
        b = a;
        System.out.println(Double.MAX_VALUE);//1.7976931348623157E308
        System.out.println(Double.MIN_VALUE);//4.9E-324
        double c = Double.valueOf(2.12);
        System.out.println(c);//2.12
        double d = Double.parseDouble("2.12");
        System.out.println(d);//2.12
        Double e = null;
        Double f = new Double(3.45);
        //获取整型部分的数据
        System.out.println(f.intValue());//3
        //完整的小数数据
        System.out.println(f.doubleValue());//3.45
    }
}

基本数据类型和对象类型的区别：

1. 对象类型除了能实现基本数据类型的数据功能，还有额外的属性和方法；
2. 对象类型可以赋值为null，基本类型不可以；
3. 对象类型和相对应的基本数据类型可以相互赋值。

Integer的缓存：

Integer类型对数值处理做了优化，如果是-128~127之间的数据直接从缓存中获取，超出这个范围的数据，都是单独创建的整形对象，所以用==比较的结果为false，用equals比较的结果为true。