JavaSE进阶学习

逍遥_D
249 阅读17分钟

一、private关键字

  • 是一个权限修饰符

  • 可以修饰成员（成员变量和成员方法）

  • 被private修饰的成员只有在本类中才能访问

  • 权限修饰符

    • private
    • (默认、缺省的)
    • protect
    • public

  • 针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作

  • 提供“get变量名（）”方法，用于获取成员变量的值，方法用public修饰

  • 提供“set变量名（）”方法，用于设置成员变量的值，方法用public修饰

  • public class Student2 {
private int age;
    private String name;
​
    //    设置年龄
    public void setAge(int n) {
    //     判断传入的年龄的值是否符合
        if (n >= 0 && n <= 120) {
            age = n;
        } 
        else {
            System.out.println("您输入的年龄有误");
        }
    }
    //    获取年龄
    public int getAge() {
        return age;
    }
}

  • 
public class Student2Test {
    public static void main(String[] args) {
        Student2 st2 =new Student2();
        st2.setAge(18);
        System.out.println(st2.getAge());
​
    }
}

二、封装

  • 封装体现的是一种思想

  • 面向对象三大特征之一（封装、继承、多态）

  • 隐藏实现细节，仅对外暴露公共访问方式

  • 封装常见的体现：

    • 1.私有成员变量，提供setXxx和getXxx方法
    • 2.将代码抽取到方法中，这是对代码的一种封装
    • 3.将属性抽取到类当中，这是对数据的一种封装

  • 封装的好处：

    • 1.提高了代码的安全性
    • 2.提高了代码的复用性

三、Java内存图

  • 1、栈：

    • 方法运行时所进入的内存

  • 2、堆：

    • new出来的东西会在这块内存中开辟空间并产生地址

  • 3、方法区

    • 字节码文件中的方法

  • 4、本地方法栈

  • 5、寄存器

四、二维数组

  • 二维数组是一种容器，该容器用于存储一维数组；

  • 
//        定义一个二维数组
int[][] arr1 = {{11,2211,22,33},{1,2,3,4,5,6}};
​
//        遍历数组
  for (int i=0;i<arr1.length;i++){
      for(int j=0;j<arr1[i].length;j++){
//  i代表的是二维数组的索引，j代表的是一维数组的索引
            System.out.print(arr1[i][j]+" ");
    }
            System.out.println();//换行
}
​

  • 索引i代表的是二维数组的索引，j代表的是一维数组的索引

  • 
格式：数组类型[][]  数组名 = new 数组类型[m ][n]
  • m表示这个二维数组，可以存放多少个一维数组
  • n表示每一个一维数组，可以存放多少个元素

五、构造方法

  • 1.概述

    • 构建、创造对象的时候，所调用的方法

  • 2.格式

    • 1.方法名与类名相同，大小写也要一致
    • 2.没有返回值类型，连void都没有
    • 3.没有具体的返回值（不能由return带回结果数据）

  • 3.执行机制

    • 1.创建对象的时候调用，每创建一次对象，就会执行一次构造方法
    • 2.不能手动调用构造方法

  • 4.构造方法的作用

    • 用于给对象的属性（数据）进行初始化

  • 5.构造方法注意事项：

    • 1.构造方法的创建

      • 如果没有定义构造方法，系统将会给出一个默认的无参数构造方法
      • 如果定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法

    • 2.构造方法的重载

      • 如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法

    • 3.推荐的使用方式

      • 无论是否使用，都手动书写无参数构造方法和带参数构造方法；

六、String

  • 字符串对象不能更改内容，不能修改；
  • 如果修改后查看地址值，发现地址值不一样，不是原来的对象，所以字符串对象内容不可以改变
  • Java 程序中所有的双引号字符串，都是 String 类的对象
  • 字符串不可变，它们的值在创建后不能被更改
  • 虽然 String 的值是不可变的，但是它们可以被共享

常量优化机制

  • Java中存在常量优化机制，字面量运算会在编译期完成，
  • 
例如 String s1 = 'a'+'b'+'c';
    String s2 = "abc";
    sout(s1==s2); //true
  • 如果是常量的计算，会在编译期就得到结果，运行的时候已经是最终结果了

1.遍历字符串

  • 方法一：

    • 
for(int i=0;i<s.length;i++){
    s.charAt(i);//就是索引处的字符值
}

  • 方法二：

    • 
//将字符串拆分为字符数组
char[] chars = s.toCharArray();
//遍历字符数组
for(int i=0;i<chars.length;i++){
    char[] chs = chars[i])
}

2.统计字符次数

  • 方法一：

    • 
if(c >= 'A'&&c<='Z'){
    bigCount++;
    //大写字符
}else if(c>='a' && c<='z'){
    smallCount++;
    //小写字符
}else if(c>=0 && c<=9){
    numCount++;
    //数字
}

3.字符串截取

  • 方法一：

    • String substring (int beginIndex);
    • 从传入的索引位置处，向后截取，一直截取到末尾，得到新的字符串并返回
    • 
String s = "qwertyuiop"
String ss=s.substring(2); 
//ss = "ertyuiop"

  • 方法二：

    • String substring (int beginIndex, int endIndex;
    • 从beginIndex索引位置开始截取，截取到endIndex索引位置，得到新字符串并返回（包含头，不包含尾）
    • 
String s = "qwertyuiop"
String ss=s.substring(0,2);
//ss = "qw"

4.字符串切割

  • 例如“张三，23”，从该字符串中切割出有效数据，封装为Student学生对象

  • 方法一：

    • String[] split(String regex) :根据传入的字符串作为规则进行切割，将切割后的内存存入字符串数组中，并将字符串数组返回
    • 这里可以将逗号作为分隔符，是其返回一个字符数组
    • 从得到的字符串数组中取出数组元素内容，通过Student类的有参构造方法封装为对象
    • 通过调用对象getXxx()方法，取出数据并打印
    • 
stuInfo = "张三，23";
//根据逗号切割字符串，得到（张三）（23）
String[] sArr = stuInfo.split(",");
//从得到的字符串数组中取出数组元素内容，通过Student类的有参构造方法封装为对象
Student stu = new Student(sArr[0],sArr[1]);
//通过调用对象getXxx()方法，取出数据并打印
System.out.println(stu.getname()+"--"+stu.getAge());

5.StringBuilder

  • StringBuilder是一个可变的字符串类，我们可以把它看成是一个容器， 操作字符串的容器

  • 作用：提高字符串的操作效率

  • 常用方法：

    • append(任意类型)，添加数据，返回对象本身
    • reverse(), 返回相反的字符序列
    • length(),返回长度(字符出现的个数)
    • toString(), 可以实现把StringBuilder转换为String

  • 链式编程

    • 如果一个方法返回的是对象类型，对象就可以继续向下调用方法
    • 例如：sb.append("红色").append("蓝色").append("绿色");

  • StringBuilder和String的区别

    • String ：内容是不可变的
    • StringBuilder：内容是可变的

  • StringBuilder提高效率的原因

    • 做多次拼接只开辟一个内存空间
    • String做一次拼接开辟2个内存空间

StringBuilder和String的相互转换

  • StringBuilder转换为String

    ​ public String toString()：通过 toString() 就可以实现把 StringBuilder 转换为 String

  • String转换为StringBuilder

    ​ public StringBuilder(String s)：通过构造方法就可以实现把 String 转换为 StringBuilder

6.API应用程序编程接口

  • （Application Programming Interface）
  • Java API ：指的就是JDK中提供的各种功能的Java类

7.字符串的比较

  • 比较基本数据类型：比较的是具体的值;比较a和b（a==b）

  • 比较引用数据类型：比较的是对象地址值;比较a和b（a.equals(b)）

  • 字符串常量池：当使用双引号创建字符串对象的时候，系统会检查该字符串是否在字符串常量池中存在

    • 不存在：创建
    • 存在：不会重新创建，而是直接复用
    • JDK7之后字符串常量池从方法区移到了堆内存

8.字符串敏感词替换

  • 替换敏感词String replace(CharSequence target, CharSequence replacement)
  • 将当前字符串中的target (被替换的旧值 )内容，使用replacement (替换的新值) 进行替换返回新的字符串

七、补充知识点

  • 1.switch语句

    • 
switch(){}
()中可以跟的数据类型：byte/short/ int/ char /枚举 /string

八、集合

  • 1、集合和数组的区别

    • 共同点：都是存储数据的容器
    • 不同点：数组的容量是固定的，集合的容量是可变的

  • 2.如果存储的数据，长度经常发生改变，推荐使用集合

  • 3.打印StringBuilder和集合的对象名都不会出现内存地址

    1.ArrayList

    • 构造方法:

      • ArrayList()构造一个初始容量为10的空列表

    • 成员方法：

      • 添加

        • boolean add(E e),将指定的元素添加到此列表的尾部
        • void add(int index,E element)将指定的元素插入此列表中的指定位置

    • 注意

      • 集合容器如果没有加入<>,就可以存储任意数据类型
      • 
<E>泛型：对集合容器存储的数据类型进行限制
​
E   需要使用引用数据类型

    • 
ArrayList<String> list = new ArrayList<>();
//字符串类型的集合创建

    • 
ArrayList list = new ArrayList();
//任意类型的集合创建

    • 
//调用对象的add方法，向容器中添加数据
list.add("abc");

    • 
//调用对象的add方法，向容器中0号索引添加数据123
list.add(0，"123");

  • 集合常用方法

    • 添加

      • boolean add(E e),将指定的元素添加到此列表的尾部
      • void add(int index,E element)将指定的元素插入此列表中的指定位置
      • 返回值是布尔值

    • 删除：

      • public boolean remove(Object o) , 删除指定的元素，返回删除是否成功
      • public E remove (int index) ; 删除指定索引处的元素，返回被删除的元素

    • 修改

      • public E set(int index,E element) ; 修改指定索引处的元素，返回被修改的元素

    • 查询

      • public E get(int index ); 返回指定索引处的元素，返回查询的元素

      • public int size() 返回集合中的元素的个数 ，返回查询到的个数

九、方法

  • 1.方法的参数传递

    • 基本数据类型参数传递的是值；（例如：int /double等 基本类型，参数传递的是值）
    • 引用数据类型参数传递的是地址；（例如数组，参数传递的是地址）

十、Static关键字

static介绍

  • static关键字是静态的意思，是Java中的一个修饰符，可以修饰成员方法，成员变量
  • 被static修饰的成员变量，一般叫静态变量
  • 被static修饰的成员方法，一般叫静态方法

static特点

  • 1被static修饰的成员，会被该类所有对象所【共享】
  • 2.被static修饰的成员，会随着类的加载而加载，优先于对象存在
  • 3.多了一种调用方式，可以通过类名点 .的方式进行调用

static注意事项

  • 1.静态随着类的加载而加载，优先于对象存在
  • 2.非静态需要在创建对象之后，才可以使用
  • 3.静态方法中，只能访问静态成员（成员变量、成员方法）
  • 4.非静态方法中，可以使用静态成员，也可以使用非静态成员
  • 5.静态方法中，没有this关键字 【this需要在创建对象之后，才会存在，静态存在的时候，对象可能还没有被创建】

十一、面向对象

  • 1.面向对象并不是一个技术，而是一种编程的指导思想；以什么形式 组织代码；以什么思路 解决问题；
  • 万物皆对象

重点学什么

  • 1.学习如何设计对象
  • 2.学习已有的对象如何使用

类和对象

  • 1.Java 中需要根据类去创建对象

  • 2.类的组成：

    • 属性:成员变量，跟之前定义变量格式一样，只不过位置需要放 在方法的外面
    • 行为：成员方法；跟之前定义方法的格式一样，只不过需要去掉 static 关键字

  • 3.创建对象

    • 
类名 对象名 = new 类名（）；

  • 4.变量的使用格式

    • 
对象名.变量名；

  • 5.方法的使用格式

    • 
对象名.方法名（实际参数）;

  • 6.注意事项：

    • 直接打印对象名，打印的是该对象在堆内存中的地址
    • 类中可以定义成员属性和成员方法，但不是必须都要有，根据需求决定
    • 定义成员属性可以不用赋值，创建对象时会给该对象的属性默认值
    • 一个类的多个对象的属性数据，相互独立不影响

成员变量和局部变量

  • 1.位置：成员变量方法外； 局部变量方法中
  • 2.初始化：有默认值； 没有，使用之前要复制
  • 3.内存位置：栈内存； 堆内存
  • 4.生命周期：随着对象的创建而存在，随着对象的消失而消失；随着方法的调用到而存在，随着方法的运行结束而消失
  • 5.作用域：自己归属的大括号
  • 
类中位置不同：
 *      成员变量在方法外，局部变量在方法内
初始化值不同：
 *      成员变量有默认初始化值，局部变量没有
内存位置不同：
 *      成员变量空间在堆内存，局部变量空间在栈内存
生命周期不同：
 *      成员变量随着对象出现而出现，随着对象消失而消失
 *      局部变量随着方法调用并定义而存在，随着方法结束而结束
 作用域：
 *      都在自己归属的大括号中
​

this 关键字


作用：解决成员变量和局部变量同名的问题
      this：代表当前类对象的引用（地址）
  • Java就近原则：不是代码距离的远近，是内存空间的距离，比如执行时在栈内存

构造方法

  • 1.构造器

    • 初始化一个新建的对象
    • 构建，创建对象的时候，所调用的方法就是构造方法

  • 2.格式

    • 1.方法名与类名相同，大小写也要一致
    • 2.没有返回值类型，连void都没有
    • 3.没有具体的返回值（不能由return带回结果数据）

  • 3.构造方法作用

    • 本质作用：给对象中的属性（成员变量）进行初始化

  • 4.构造方法也可以重载（空参构造和带参构造）

  • 5.构造方法的作用是给对象属性赋值！ 构造方法是创建对象这句话是错误的。

  • 6.new关键字才是创建对象的！它有两个功能，第一是创建对象，第二是调用构造方法！

  • 7.构造方法不能用来修改属性值！

封装

  • 1.将属性抽取到类中，这是对数据的一种封装
  • 2.将功能抽取到方法中，这是对方法的封装
  • 隐藏实现细节，仅对外暴露公共访问方式

JavaBean

  • 定义属性：用private修饰，提高安全性
  • 定义构造：提供空参、满参构造
  • 操作属性的方法：set和get方法
  • 可以使用IDEA一键生成

十二、static关键字

作用

  • static关键字:让对象可以共享属性数据,让方法调用更加简单

static修饰成员变量-静态属性

  • static修饰的类属性,被这个类所有对象所共享

    
//关于静态的属性,推荐使用类名调用:格式:类名.静态属性名
//因为使用对象访问,底层还是用类名访问
    1. 被static修饰的成员,会被该类的所有对象所[共享]
    2. 被static修饰的成员,会随着类的加载而加载,优先于对象而存在
    3. 多了一种调用方式,可以通过类名 点 . 进行调用

  • 定义:static关键字是静态的意思,是Java中的一个修饰符,可以修饰 成员方法,成员变量

    • 被static修饰的成员变量,一般叫做静态成员变量,
    • 被static修饰的成员方法,一般叫做静态方法

注意事项:

  • 静态随着类的加载而加载,优先于对象存在,
  • 非静态需要在创建对象之后,才可以进行使用
  • 1.静态方法中,只能访问静态成员(成员变量/成员方法)
  • 2.非静态方法中,可以使用静态成员,也可以使用非静态成员
  • 3.静态方法中,没有this关键字

this关键字

  • this:当前对象的引用
  • this需要在创建对象之后,才会存在,静态存在的时候,对象可能还没有被创建

成员方法的分类

  • 静态成员方法(有static修饰,属于类),建议用类名访问,也可以用对象访问[本质上还是类名调用]
  • 实例成员方法（无static修饰，属于对象），只能用对象触发访问
  • 静态成员不能访问非静态成员
  • 静态方法不能访问没有被static修饰的成员,只是不能直接访问,但是可以创建对象访问;
  • 为什么呢? 原因:静态成员是随着类加载的,此时对象可能没有创建;

使用场景

  • 如果方法不用访问实例成员并且需要需要方便调用，可以声明成静态方法
  • 方法中需要访问实例成员的，该方法必须声明成实例方法

十三.单例设计模式

设计步骤

  • 1.把类的构造器私有
  • 2.创建类的对象,并定义一个静态变量记住这个对象
  • 3.定义 一个方法,返回上面创建的对象

饿汉设计模式

懒汉设计模式


//静态属性记录了一个Music对象，类加载对象就创建，属于饿汉单例模式
    //private static QQ qq = new QQ();
    //改进:不用new
    private static QQ qq ;
    
    
    /*在需要的时候才创建
    * */
    public static  QQ getInstance(){
        if (qq == null){
            qq = new QQ();
        }
        return qq;
    }
​


//1.改进之前,QQ类之前使用饿汉单例设计模式,这时我想看看qq的信息,调用show()方法
        //  改进之后,这里只会进行展示信息功能, 不会自动下载
        QQ.show();
​
        //2.改进qq,如果只是想看看QQ的信息,就不希望吧对象创建出来,只有当我真正想用的时候再去创建
        //   调用getInstance 会创建QQ 对象, 会进行下载操作
         QQ.getInstance();

十四.继承

继承特点

  • 1.什么是继承、继承的好处

    • 继承用extends关键字，让一个类和另一个类建立起一种父子关系
    • 提高代码复用性，减少代码冗余

  • 2.继承的格式

    • 子类 extends 父类

  • 3.继承后子类的特点？

    • 子类继承父类，子类可以得到父类的属性和行为

  • 4.继承需要满足什么样的设计规范？

    • 子类们相同特征（共性属性，共性方法）放在父类中定义
    • 子类独有的的属性和行为应该定义在子类自己里面

  • 5.详解继承的特点

    • 子类可以继承父类非私有的属性和行为，但是子类不能继承父类的构造器。
    • Java是单继承模式：一个类只能继承一个直接父类。
    • Java不支持多继承、但是支持多层继承。
    • Java中所有的类都是Object类的子类。

  • 6.子类不能继承父类的构造器,构造器需要new ,不能继承

  • 7.在子类方法中访问成员（成员变量、成员方法）满足：就近原则

    • 先子类局部范围找
    • 然后子类成员范围找
    • 然后父类成员范围找，如果父类范围还没有找到则报错

  • 8.如果子父类中，出现了重名的成员，会优先使用子类的，此时如果一定要在子类中使用父类的怎么办？

    • 可以通过super关键字，指定访问父类的成员
    • 格式:super.父类成员变量/父类成员方法
    • super写在哪个类里面,访问的就是哪个类的父类

方法重写

  • 在继承中,子类出现了个父类一模一样的方法声明,我们称子类的方法就是方法重写

  • 应用场景:

    • 当子类需要父类的功能,但父类的功能不能完全满足需求,子类可以重写父类中的方法

  • 子类不能重写父类的静态方法


方法重写涉及到的一些细节问题：
一、@Override重写注解
@Override是放在重写后的方法上，作为重写是否正确的校验注解。
加上该注解后如果重写错误，编译阶段会出现错误提示。
建议重写方法都加@Override注解，代码安全，优雅！
​


二、方法重写注意事项和要求
重写方法的名称、形参列表必须与被重写方法的名称和参数列表一致。
私有方法不能被重写。
子类重写父类方法时，访问权限必须大于或者等于父类 （暂时了解 ：缺省 < protected < public）
子类不能重写父类的静态方法，如果重写会报错的。
​


方法重写建议加上哪个注解，有什么好处？
@Override注解可以校验重写是否正确，同时可读性好。
重写方法有哪些基本要求？
重写方法的名称和形参列表应该与被重写方法一致。
私有方法不能被重写。
子类重写父类方法时，访问权限必须大于或者等于父类被重写的方法的权限。
​

子类继承父类后构造器的特点

    1. 子类中所有的构造器默认都会先访问父类中无参的构造器,再访问自己

  • 为什么？

    • 子类初始化的时候，有可能会使用到父类中的数据。如果父类没有完成初始化，子类就无法使用父类的数据子类初始化之前，一定要调用父类构造器先完成父类数据空间的初始化

  • 怎么调用父类构造器的？

    • 子类构造器的第一行语句默认都是：super()，不写也存在

如果父类中没有无参数构造器，只有有参构造器，会出现什么现象呢？
会报错。因为子类默认是调用父类无参构造器的
​
如何解决？
子类构造器中可以通过书写 super(参数值)，手动调用父类的有参数构造器
​
推荐解决方案:在给一个类定义构造的时候,把空参/有参数都给上
​
super调用父类有参数构造器的作用：
 初始化继承自父类的数据
​

this和super

  • this:代表本类对象的引用
  • super:代表父类存储空间的标识

this(...)和super(…)使用注意点：

  • 子类通过 this (...）去调用本类的其他构造器，本类其他构造器会通过 super 去手动调用父类的构造器，最终还是会调用父类构造器的
  • 注意：this(…) super(…) 都只能放在构造器的第一行，所以二者不能共存在同一个构造器中

Object特点

  • Java中的所有类,要么直接继承了Object,要么默认继承了Object,要么间接继承了Object;
  • Object是祖宗类

十五、final

final的作用

  • final 关键字是最终的意思，可以修饰方法，变量，
  • 类修饰方法：表明该方法是最终方法，不能被重写
  • 修饰变量：表示该变量第一次赋值后，不能再次被赋值
  • 修饰类：表明该类是最终类，不能被继承

final修饰变量的注意

  • 1.final修饰成员变量的时候,需要给它指定值,或者在构造中给它值;赋值后不能发生改变
  • final修饰的变量是基本类型：那么变量存储的数据值不能发生改变
  • final修饰的变量是引用类型：那么变量存储的地址值不能发生改变，但是地址指向的对象内容是可以发生变化的

十六、常量

  • 在程序运行期间,其值不能发生改变的量

常量的作用

  • 可以用于做系统的配置信息,方便程序的维护,提高可读性

  • 
使用final修饰的基本数据类型变量都是常量
使用final修饰的String类型变量也是常量

  • 一般的引用数据类型,用final修饰,不能算常量,因为对象的属性值可以改变

  • 命名规范

    • 英文单词全部大写，多个单词下划线连接起来。

  • 宏替换

    • 当定义final变量时就为该变量指定了初始值，并且这个初始值在编译时就可以确定，那么这个变量就是“宏变量”。编译期会把程序中所有用到这个变量的位置直接替换成该变量的值。

十七、抽象类

  • 在Java中abstract是抽象的意思,如果一个类中的某个方法的具体实现不能确定,就可以申明成abstract修饰的抽象方法(不能写方法体了),这个类必须用abstract修饰,被称为抽象类
  • 抽象类格式: 
修饰符 abstract class类名{}

  • 抽象方法格式:
修饰符 abstract 返回值类型 方法名称(形参列表);

注意事项

  • 得到了抽象方法,失去了创建对象的能力

  • 抽象类为什么不能创建对象?

    • 类有的成员(成员变量/方法/构造器)抽象类都具备
    • 抽象类中不一定有抽象方法,有抽象类方法的类一定是抽象类
    • 一个类继承了抽象类必须重写抽象类的全部抽象方法,否则这个类也必须是抽象类
    • 不能用abstract修饰变量/代码块/构造器

  • final和abstract是互斥关系,被abstract修饰的类是希望别人继承的,但是final修饰的类是不让别人继承

十八、接口

接口概述与特点

  • 什么是接口

    • 接口也是一种规范

  • 接口格式

    • 
public interface 接口名{
    //常量
    //抽象方法
}
    • JDK8之前接口中只能是抽象方法和常量,没有其他成分
    • 接口不能实例化
    • 接口中的成员都是public修饰的,写不写都是,因为规范的目的是为了公开化

  • 接口中成员的特点:

    • 成员变量:

      • 只能是常量, 系统会默认加上三个关键字
      • public static final

    • 构造方法:

      • 没有

    • 成员方法

      • 只能是抽象方法
      • 系统会默认加上 public abstract

接口的基本使用:被实现

  • //jdk8以前,接口中只能有抽象方法和常量,这个常量也是希望直接提供给别人使用的
//比如圆周率,而且圆周率不能改变,所以是常量
//接口不能创建对象,所以属性名也得是静态的,这样别人才能通过接口名直接调用
 //public final static double PI  = 3.1415926759;
    double PI = 3.1415926759;

  • //抽象方法
//public abstract对于接口的抽象方法可以省略
//public abstract void squaring();
void squaring();

  • 接口是用来被类实现(implements)的,实现接口的类称为实现类.实现类可以理解成所谓的子类

    • 格式:
修饰符 class 实现类 implements 接口1,接口2,接口3{
    
}
//实现的关键字:implements
    • 接口可以被类单实现,也可以被类多实现

接口与接口的关系:多继承

  • 类和类的关系:单继承
  • 类和接口的关系:多实现
  • 接口和接口的关系:多继承,一个接口可以同时继承多个接口
  • 作用:整合多个接口,方便子类实现

十九、多态

多态概述

  • 同一个对象,在不同时刻表现出来的不同形态

多态的前提

  • 1.要有(继承/实现)关系
  • 2.要有方法重写
  • 3.要有父类引用,指向子类对象
Fu f = new Zi();

多态中成员访问特点

  • 构造方法:同继承一样,子类会通过super访问父类构造方法
  • 成员变量:编译看左边(父类) , 运行看左边(父类)
  • 成员方法:编译看左边(父类) , 运行看右边(子类)

多态的好处与弊端

  • 多态的好处:提高了程序的拓展性,

    • 具体体现:定义方法的时候,使用父类型作为参数,该方法就可以接收父类的任意子类对象

  • 多态的弊端:不能使用子类的特有功能

  • 弊端解决方案

    • A:直接创建子类对象
    • B:向下转型
    • 向下转型:从父类类型,转换回子类类型
Zi z = (Zi)f;

多态中的转型

  • 向上转型

    • 从子到父
    • 父类引用指向子类对象

  • 向下转型

    • 从父到子
    • 父类引用转为子类对象

JDK8版本中接口成员的特点-默认方法

  • JDK8版本后,

    • 允许接口中定义非抽象方法,但是需要使用default修饰,这些方法都是默认方法
    • 作用:解决接口升级问题

  • 格式

    • 
public default 返回值类型 方法名(参数列表){
    
}

    • 
public default void show(){
    
}

  • 注意事项:

    • 默认方法不是抽象方法,不强制被重写
    • 但是可以被重写,重写时去掉default关键字
    • public 可以省略,default不能省略
    • 如果实现了多个接口,多个接口中存在相同的方法声明,子类就必须对该方法进行重写

JDK8版本中接口成员的特点-静态方法

  • JDK8版本后

    • 1.允许在接口中定义非抽象方法,但是需要使用关键字default修饰,这些方法就是默认方法

      • 作用:解决接口升级问题

    • 2.接口中允许定义static静态方法

  • 格式:

    
public static 返回值类型 方法名(参数列表){
    
}

    
public static void show(){
    
}

  • 注意事项:

    • 静态方法只能通过接口名调用,不能通过类名或者对象名调用
    • public可以省略,static不能省略

JDK9版本中接口成员的特点-私有方法

  • 限制在本类中使用,加上private关键字修饰
  • 作用:解决方法中出现的重复代码

接口的使用思路

  • 如果发现一个类中所有的方法都是抽象方法,那么就可以将该类,改进为一个接口
  • 涉及到了借口大面积更新方法,而不想去修改每一个实现类,就可以将更新的方法,定义为带有方法体的默认方法
  • 希望默认方法调用的更加简洁,可以考虑设计为static静态方法(需要去掉default关键字)
  • 默认方法中出现了重复的代码,可以考虑抽取一个私有方法(需要去掉default关键字)

end

\

avatar
文章
阅读
粉丝