封装和继承

1.封装

何为封装？

封装，就是隐藏对象的属性和实现细节，仅对外公开接口（方法/函数），控制在程序中属性的读和修改的访问级别；将抽象得到的数据和行为（或功能）相结合，形成一个有机整体，也就是将数据与操作数据的源代码进行有机结合，形成类，其中属性数据和函数都是类的成员。

封装的目的：

封装的目的在于增强安全性和简化编程，使用者不需要了解具体实现细节，而只需要通过外部接口，以特定的访问权限来使用类的成员。

广义上来说，一切公共代码的抽取都可以叫封装；

我们所说的工具类就是一种封装；

狭义上来说：封装是隐藏对象的属性和实现细节；

1.将属性私有化，即使用private关键字进行修饰；

2.为被private关键字修饰的属性添加gettersetter方法，意义在于通过get和set方法来操作属性

3.在setter方法中添加数据的逻辑校验；

下面这段代码就是一种封装。fengzhuan

public class Student {
    private String name;
    private String sex;
    private int age;
    public Student(String name,String sex,int age){
        this.name = name;
        this.sex = sex;
        if (age<0||age>120){
            System.out.println("年龄输入错误！");
        }else {
            this.age = age;
        }
    }
    public void setAge(int age) {
        if (age<0||age>120){
            System.out.println("年龄输入错误！");
        }else {
            this.age = age;
        }
    }

    public int getAge() {
        return age;
    }

    public String getName() {
        return name;
    }

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

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        if (sex.equals("男") || sex.equals("女")){
        this.sex = sex;
        }else {
            System.out.println("性别输入错误！");
        }
    }
}

封装完成以后，在使用时就需要通过get和set方法来操作数据：

public class PrivateTest {
    public static void main(String[] args) {
        Student s1 = new Student("张三","女",-21);
        s1.setName("张三");
        s1.setAge(1000);
        s1.setSex("未知");
        //s1.setAge(20);
        s1.setSex("男");
        System.out.println(s1.getName());
        System.out.println(s1.getAge());
        System.out.println(s1.getSex());
    }
}

 2.继承

什么是继承？

继承是面向对象软件技术当中的一个概念，与多态、封装共称为面向对象的三个基本特征。继承可以使得子类具有父类的非私有属性和方法或者可以重新定义、追加属性和方法等。

继承（英语：inheritance）。这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。

继承就是子类继承父类的特征和行为，使得子类对象（实例）具有父类的属性和方法，或子类从父类继承方法，使得子类具有父类相同的行为。

子类和父类的关系来源就在于继承，例如B类继承于A类，那么B类就是A类的子类或称之为派生类，而A类就是B类的父类也可以成为超类或基类。

继承的作用：

1.提高代码的重用性，子类具有父类的属性和方法等，不需要在子类中重写一遍代码；

2.能够在父类的基础上进行功能拓展；

3.便于维护，当多个子类同时继承父类的某种功能或属性时，只需要更改父类中的功能或属性就可以完成子类中功能或属性的变更；

继承的语法格式：

在Java语言中继承是单继承，即一个类只能由一个父类，但是在Java中可以多级继承，就是子类只可以有一个直接父类，而父类又可以有一个直接父类，也就是爷爷辈，同时一个父类可以有多个子类，就是兄弟。

基础语法为：【权限修饰符】class  子类名 extends 父类名{}

例如：

先定义一个父类

public class FatherClass {
    String name;
    String sex;
    public void callSon(){
        System.out.println("这是父类中的方法");
    }
}

 在定义一个继承于FatherClass 的子类：

public class SonClass extends FatherClass{

}

最后进行测试：

public class Father_Son_Test {
    public static void main(String[] args) {
        SonClass sc = new SonClass();
        sc.callSon();
        sc.name = "张三";
        sc.sex = "男";
        System.out.println(sc.name+"\t"+sc.sex);
    }
}

测试结果：

这是父类中的方法
张三	男

可以看出，虽然在sonClass中没有定义name、sex等属性以及callSon（）方法，但是我们在创建sonClass对象以后，却可以使用这些属性和方法，这是因为子类继承了父类中的方法和属性

在继承里面有一个重要的点是方法的重写
方法重写又成为方法覆盖，方法重写的意义在于当子类并不想完全按照父类的方法执行，就可以进行方法重写，来改变方法的内容。

例如：

这里的callSon（）方法就进行了方法重写

public class SonClass extends FatherClass{
    @Override
    public void callSon() {
        System.out.println("先调用父类中的方法以便区分");
        super.callSon();
        System.out.println("在子类中进行了方法重写");
    }
}

方法重写的注意事项：

• 必须保证父子类中重写的方法，方法名相同，参数列表相同。

• 子类方法的返回值必须小于或等于父类方法的返回值范围。

• 子类方法的权限必须要大于等于父类方法的权限（不包括 private）

• 子类重写方法异常声明必须是父类的异常或子级异常

• 私有的不能被继承

super关键字和this关键字

super：访问父类中的东西

this：访问自己的东西

例如：

public class SonClass extends FatherClass{
    @Override
    public void callSon() {
        System.out.println("先调用父类中的方法以便区分");
        super.callSon();
        System.out.println("在子类中进行了方法重写");
    }
}

任何类都是Object类的直接子类或间接子类，而在Object类中有一个toString() 方法。当输出一个对象时，先调用当前类的toString()方法，如果当前类没有该方法，就到当前类的父类中去找，看是否有该方法，如果父类中也没有，就需要到Object类找到该方法去运行。

数据模型类

在Java面向对象开发中，类一般包括，私有化的成员属性，成员方法，构造方法，get/set方法，toString方法。

在继承中，构造方法的特点（父子类）

特点 ：

• 构造方法不能被继承（构造方法是一个类独有的方法）

• 创建子类对象一定是先调用父类构造，再调用子类构造。(并且只有子类构造才能调用父类构造)。

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

• super父类构造调用，必须是子类构造中的第一行语句。(并且一个子类构造，只能调用一次super())。必须先有父再有子。

 3.Object类

理论上而言，Object是所有类的直接父类或间接父类，因此在代码编写的时候就省去了extends Object的关键字。在Object类中主要方法有：toString(),getClass(),equals(),finalize()，其中toString(),getClass(),equals()是其中最重要的方法。

注意：

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

Object类中的equals()方法进行字符串比较时比较的是地址值，而String类中的equals()方法是进行重写过的方法，所以可以比较值。

4.final关键字

final代表最终的，不可改变的

我们常说的字符串不可变，就是由于String类是由final关键字修饰的。

final关键字的三种用法：

1.修饰类

        final修饰的类不可以被继承。

2.修饰方法

        final修饰的方法不可被重写，代表着最终的方法。

3.修饰变量

        final修饰的变量视为常量，值不可变。变量名必须全部大写，一般多个单词使用下划线连接

使用final关键字修饰的基本数据类型的变量，其数据类型不可改变，并且只能进行一次赋值

使用final关键字修饰的引用数据类型的变量，引用的地址不可改变，但是对像的属性值可以改变。

• 对于成员变量来说，使用final 修饰照样是不可变的，但是因为成员变量有默认值，所以必须手动赋值。

• 对final修饰的成员变量来说，可以直接赋值，也可以通过构造方法赋值，但是必须二选一。

• 如果要通过构造方法赋值，并且类中有多个构造方法，必须保证每一个构造方法都要对final修饰的成员变量赋值。

5.基本类型（四类八种）包装类

概念

        对于基本数据类型来说，使用起来非常方便，但是我们没有对应的方法去操控它们，可以通过一个类把基本数据类型包装起来，在类中定义一些方法，这个类就叫做包装类。我们可以使用包装类中定义的方法去操作基本数据

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

一般为首字母大写，例如byte对应Byte，short对应Short

特殊的比如：int Integer，char Character

自动装箱与拆箱

装箱：基本数据类型转化为包装类

拆箱：包装类转化为基本数据类型

基本数据类型与字符串之间的转化

1.直接使用数字+空字符串

2.使用包装类中的toString()方法

3.使用String类中的valueOf（）方法

数字类型字符串转化为数字

使用包装类的方法xxx.parseXXX()。