七、封装和继承

一、封装

1.1 什么是封装?

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

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

1.2 java中的封装

广义来说:一切公共代码的抽取都可以叫封装。

​ 一般体现在公共方法的封装。工具类。

狭义来说:隐藏对象的属性和实现细节。

  1. 将属性私有化 ,使用private关键字修饰。
  2. 为使用private关键字修饰的属性添加 getter和setter方法。通过get和set方法来操作属性。
  3. 在setter方法中,添加数据的逻辑校验
package com.test3;
​public class Student {
    //属性封装:1.属性私有化 2.添加getter setter方法 3.在setter方法中进行数据校验
    //姓名
    private String name;
    //性别
    private  String sex;
    //年龄
    private int age;
    public void show(){
        System.out.println(this.name+" "+this.sex+" "+this.age);
    }​
    //生成getter setter
    public String getName() {
        return name;
    }​
    public void setName(String name) {
        this.name = name;
    }​
    public String getSex() {
        return sex;
    }​
    public void setSex(String sex) {
        //在setter方法中对数据进行校验
        if(sex.equals("男")||sex.equals("女")){
            this.sex = sex;
        }else{
            System.out.println("性别无效");
        }
    }​
    public int getAge() {
        return age;
    }​
    public void setAge(int age) {
        if(age>0 && age<120){
            this.age = age;
        }else{
            System.out.println("年龄超出范围");
        }
    }
    }​
package com.test3;​public class Test {
​    public static void main(String[] args) {
        Student s=new Student();
//      s.name="张三";
//      s.sex="石头";
//      s.age=-20;
        s.setName("张三");
        s.setSex("石头");
        s.setAge(-20);
        s.show();
    }
}

 1.3 封装的作用

        保护属性的有效性。

二、继承

2.1 什么是继承

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

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

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

        如果某类B“继承”另某类A,就把这个B称为“A的子类派生类(subclass)”,而把类A称为“B的父类”也可以称为“A是B的超类基类(superclass)”。

2.2 为什么需要继承

提升代码的可重用性

  • 子类通过继承可以得到父类有的内容

能够扩展功能

  • 通过继承,子类可以扩展父类已有的功能

方便维护

  • 多个子类都继承了父类的某个功能,当功能需要修改时,只要修改父类的这个功能即可

使用面向对象思想编程的时候,需要考虑的两个方面:

​ 1.功能实现了没有?

​ 2.后期维护方便吗?

2.3 继承的语法格式

java语言是单继承的,java类只能由一个父类。

继承的语句格式:

[权限修饰符] class 子类名 extends 父类名{}
// 定义父类public class Father {
    // 父亲有500w元
    int money = 5000000;​
    public void liveHouse(){
        System.out.println("住80年代老房子");
    }
}/

/ 定义子类
public class Son extends Father{}​public class Test {
    public static void main(String[] args) { 
       Son son = new Son(); 
       System.out.println("儿子有:"+son.money+"元");
       son.liveHouse();
    }
}

 运行结果:

儿子有:5000000元
住80年代老房子

2.4  方法重写 @Override注解

什么是方法重写

​ 在Java和其他一些高级面向对象的编程语言中,子类可继承父类中的方法,而不需要重新编写相同的方法。但有时子类并不想原封不动地继承父类的方法,而是想作一定的修改,这就需要采用方法的重写。方法重写又称方法覆盖

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

​重载(overload):发生在同一个类中 , 方法名相同,参数列表不同,不考虑返回值。

重写(overrides):发生在父子类中,子类继承父类的方法,方法名相同,参数也相同,但是实现方法体不同。

重写的注意事项:

  • 必须保证父子类中重写的方法,方法名相同,参数列表相同。
  • 子类方法的返回值必须小于或等于父类方法的返回值范围。
  • 子类方法的权限必须要大于等于父类方法的权限(不包括 private)
  • 子类重写方法异常声明必须是父类的异常或子级异常
  • 私有的不能被继承

toString()方法

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

数据模型类

  • 以后写类都要有:成员属性私有化,成员方法,构造方法,get/set方法 ,toString()

继承实例

// Father.java
// 父亲类
public class Father {
    // 父亲有500w元
    int money = 5000000;
​    public void liveHouse(){
        System.out.println("住80年代老房子");
    }
}​

// Son.java
// 儿子类
public class Son extends Father{
    // 重写父类方法
    @Override
    public void liveHouse() {
        System.out.println("住海景洋房");
    }
}​

// Test.java
// 测试类
public class Test { 
   public static void main(String[] args) {
        Son son = new Son();
       System.out.println("儿子有:"+son.money+"元");
        son.liveHouse();
    }
}

运行结果:

儿子有:5000000元
住海景洋房

2.5 super关键字(父类对象),this关键字(当前类对象)

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

super 关键字的用法:

  1. 在子类的成员方法中访问父类的成员变量和成员方法。
  2. 在子类的构造方法中访问父类的构造方法

 2.6 继承中构造方法的特点(父子类)

特点

  • 构造方法不能被继承(构造方法是一个类独有的方法)
  • 创建子类对象一定是先调用父类构造,再调用子类构造。(并且只有子类构造才能调用父类构造)。
  • 子类构造可以通过super关键字调用父类有参构造 无参super() 有参super(参数列表) 。
  • super父类构造调用,必须是子类构造中的第一行语句。(并且一个子类构造,只能调用一次super())。必须先有父再有子。

 

public class Fu {
    //钱
    int money = 500;
    //姓氏
    String xingshi;
    //有参构造
    public Fu(String xingshi){
        this.xingshi=xingshi;
    }
    //自我介绍
    public void introduce(){
        System.out.println("本人姓"+xingshi);
    }
//    public Fu(){
//        System.out.println("调用了Fu父类的构造方法");
//    }}public class Zi extends Fu{
    //在继承关系中的构造特点(满足先有父,再有子原则):
    //1.子类的构造会默认调用父类的无参构造,以满足先有父再有子的原则。
    //2.当父类没有无参构造,只有有参构造的时候,我们需要在子类构造的
    //  第一行代码处,使用super关键字显示调用父类构造
    public Zi(){
        //在子类构造的第一行代码处,显示调用父类构造
        super("张");
        System.out.println("调用了Zi的构造方法");
    }
    public Zi(String xingshi){
        super(xingshi);
    }
}
public static void main(String[] args) {
    //创建子类对象
    //Zi zi = new Zi();
    //System.out.println("儿子的钱:"+zi.money);
    //创建子类对象
    //new Zi();
    //创建子类
    Zi z = new Zi();
    z.introduce();
    Zi z2 =new Zi("李");
    z2.introduce();
}

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

2.7 Object类

Object是所有类的父类,任何类都默认继承Object

理论上Object类是所有类的父类,即直接或间接的继承java.lang.Object类。由于所有的类都继承在Object类,因此省略了extends Object关键字。

该类中主要有以下方法: toString(),getClass(),equals(),clone(),finalize(), 其中toString(),getClass(),equals()是其中最重要的方法。

注意:

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

equals()方法 在比较字符串时 比较的是俩个字符串的值。但是实际上equals方法比较的是地址值。

为什么String就可以用equals()比较值呢

因为String类中重写了equals()方法,所以可以比较值。

什么样的类可以构成继承关系?

如果两个类之间符合is-a(是一个)描述,

则这两个就具有继承关系

苹果是一个水果: 苹果类 继承 水果类

宝马车是一个车:宝马车 继承 车类

张三是一个人  : 张三  继承 人类

继承实例:学生管理系统,通过继承实现代码复用

学生和老师有一些共同属性。有相同的方法。通过继承人类实现代码复用

package com.test4;​public class People {
    String name;
    String sex;
        public People(String name,String sex){
        this.name=name;
        this.sex=sex;
    }
        public void show(){
        System.out.println(this.name+" "+this.sex);
    }
}
package com.test4;​public class Student extends People{
    public Student(String name,String sex){
        super(name,sex);
    }
}​
package com.test4;​public class Teacher extends People{
    String edu;
    String pos;
        public Teacher(String name,String sex,String edu,String pos){
        super(name,sex);
        this.edu=edu;
        this.pos=pos;
    }
        public void show(){
        super.show();
        System.out.println(this.edu+" "+this.pos);
    }
}
package com.test4;​public class Test {​
    public static void main(String[] args) {
        Student s=new Student("张三","男");
        s.show();
        Teacher t=new Teacher("王老师","女","博士","教授");
        t.show();
    }
}

小结

  1. 继承关键字:extends
  2. 单继承,一个类只能有一个直接父类
  3. 子类可以继承父类:public protected 同包默认的属性和方法,不能继承private私有方法
  4. 子类可以书写自己的属性和方法
  5. 子类可以重写父类的方法
  6. 在子类中可以通过super调用父类的方法和属性。super.方法名/属性名

无父无子

a. 父类构造不能继承,但是必须调用

b. new子类的时候,子类构造的第一行必须调用父类的构造方法

c.如果子类不写super(),系统默认调用父类无参构造

d.可以通过super(参数)调用有参,并且必须第一行,并且只能有一个super()。

如果通过子类调用方法,优先调用自己的方法。子类重写方法之后调用自己的方法,如果子类没有重写方法则使用父类的方法。

  1. 先子类---》再父类---》再父类--》。。。。--》Object
  2. 所有类都直接或者间接的继承了Object类。Object是所有类的基类,超类。

继承的作用:

A. 减少代码冗余

B. 书写一个父类,子类可以对父类进行扩展

C. 子类可以对父类重新定义

三、fianl关键字

final 代表最终的,不可改变的。

字符串为什么是不可变的?因为String类是用final关键字修饰的。

三种用法:

  • 可以用来修饰类

final修饰的类不能被继承,也就意味着这个类其中的方法不能被重写。

  • 可以用来修饰方法

final关键字修饰的方法不能被覆盖重写。表示一个最终的方法。

  • 可以用来修饰变量

final修饰成员变量---》常量 命名必须全大写 一般多个单词使用下划线连接D_AGE,CAT_AGE, PI

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

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

  • 对于成员变量来说,使用final 修饰照样是不可变的,但是因为成员变量有默认值,所以必须手动赋值。
  • 对final修饰的成员变量来说,可以直接赋值,也可以通过构造方法赋值,但是必须二选一。
  • 如果要通过构造方法赋值,并且类中有多个构造方法,必须保证每一个构造方法都要对final修饰的成员变量赋值。
//final修饰类,不允许被继承
public  class MyCls {
    //用final修饰的变量,称为常量。常量必须被赋值,而且一旦赋值就不能改变。
    private final String str = "aaa";
    //静态常量
    private static final String str2 ="bbb";
    //final修饰方法,改方法不能被重写
    public final void test(){
        //this.str="bbb";
    }
}
public class Student {
    String name;
    int age;}public class Test {
    public static void main(String[] args) {
        //局部常量,允许先定义再赋值。但是一旦赋值就不能改变
        final int a;
        a = 20;
        //a = 30;
        final Student s = new Student();
        s.name="张三";
        s.age = 20;
        s.name="李四";
        s.age = 18;
    }
}

四、基本类型(四类八种)包装类

4.1 概念

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

基本数据类型和对应的包装类:

byte              Byte

short            Short

int                Integer

long             Long

float             Float

double         Double

char            Character

boolean       Boolean

4.2 自动装箱与自动拆箱

  • 装箱

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

  • 拆箱

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

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

  • 基本类型(数字)----》字符串(String)
  1. 可以使用数字直接+空字符串       例如: String a = 5 + "";
  2. 使用Integer包装类的方法 toString(int i);        例如: String a = Integer.toString(100);
  3. 使用String类的方法valueOf(int i)            例如:String a = String.valueOf(100);
  • 字符串----》基本数据类型(数字)

注意:只有数字类型的字符串,才可以转换成数字

使用包装类的方法xxx.parseXXX("5"); NumberFormatException 数字格式异常

public static void main(String[] args) {
    //整形的基本类型
    int n1 = 10;
    //整形的对象类型(包装类)
    Integer n2 = 20;
    //将对象类型赋值给基本类型,拆箱(还原本质)
    //n1 = n2;
    //讲基本类型赋值给对象类型,装箱(进行包装)
    n2 = n1;
    //System.out.println(n1+n2);
    //对象类型和基本类型区别:
    //1.对象类型除了能实现基本类型的数据功能,还有额外的属性和方法
    //2.对象类型可以赋值为null,基本类型不可以
    //3.对象类型和对应的基本类型可以相互赋值(jdk高版本1.8)
    System.out.println(Integer.MAX_VALUE);
    //整形的最大值
    System.out.println(Integer.MIN_VALUE);
    //整形的最小值
    String s = Integer.toString(100);
    //讲整数转为字符串
    int x = Integer.valueOf("223");
    //讲字符串转为整数
    int x2 = Integer.parseInt("234");
    int y = Integer.max(100,200);
    //取出两个数的最大值
    System.out.println(y);
    Integer z = null;
    //对象类型可以为null
    //int c = null;
    //基本类型不能为null
}


public static void main(String[] args) {
    //基本类型的小数
    double d1 = 10.234;
    //对象类型的小数
    Double d2 = 2.234;
    //d1 = d2;
    d2 = d1;
    System.out.println(Double.MIN_VALUE);
    System.out.println(Double.MAX_VALUE);
    double d3 = Double.valueOf("2.234");
    double d4 = Double.parseDouble("4.23");
    System.out.println(d3);
    System.out.println(d4);
    Double d5 = null;
    //double d6 = null;
    //用new的方式创建Double对象
    Double d = new Double(2.234);
    System.out.println(d.intValue()); //获取整形部分的数据
    System.out.println(d.doubleValue()); //完整的小数数据}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值