java学习day9（Java基础）多态和特殊类

最新推荐文章于 2024-01-24 20:03:12 发布
最新推荐文章于 2024-01-24 20:03:12 发布
阅读量208 收藏
点赞数
分类专栏： JAVA学习笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gaosong0623/article/details/126819269
版权
目录
1. 多态
2. 抽象类
3. 接口
第一节：多态（重中之重）
多态的概念
• 多态主要指同一种事物表现出来的多种形态。
• 饮料：可乐、雪碧、红牛、脉动、...
• 宠物：猫、狗、鸟、小强、鱼、...
• 人：学生、教师、工人、保安、...
• 图形：矩形、圆形、梯形、三角形、
多态的语法格式
• 父类类型 引用变量名 = new 子类类型();
• 如：
Shape sr = new Rect();
sr.show();
案例题目
• 编程实现Shape类的封装，特征有：横纵坐标，要求提供打印所有特征的方法。
• 编程实现Rect类的封装并继承自Shape类，特征有：长度和宽度。
• 编程实现ShapeRectTest类，在main方法中分别创建Shape和Rect类型对象并打印特征。
shape类： 
package com.lagou.task09;

public class Shape {
    private int x;
    private int y;

    public Shape() {
    }

    public Shape(int x, int y) {
        setX(x);
        setY(y);
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public void show() {
        System.out.println("横坐标：" + getX() + "，纵坐标：" + getY());
    }

    // 自定义静态方法
    public static void test() {
        System.out.println("Shape类中的静态方法！");
    }
}

rect类：

package com.lagou.task09;

public class Rect extends Shape {
    private int len;
    private int wid;

    public Rect() {
    }

    public Rect(int x, int y, int len, int wid) {
        super(x, y);
        setLen(len);
        setWid(wid);
    }

    public int getLen() {
        return len;
    }

    public void setLen(int len) {
        if(len > 0) {
            this.len = len;
        } else {
            System.out.println("长度不合理哦！！！");
        }
    }

    public int getWid() {
        return wid;
    }

    public void setWid(int wid) {
        if (wid > 0) {
            this.wid = wid;
        } else {
            System.out.println("宽度不合理哦！！！");
        }
    }

    @Override
    public void show() {
        super.show();
        System.out.println("长度是：" + getLen() + "，宽度是：" + getWid());
    }

    // 自定义静态方法
    //@Override Error: 历史原因、不是真正意义上的重写
    public static void test() {
        System.out.println("---Rect类中的静态方法！");
    }
}

实现类：

package com.lagou.task09;

public class ShapeRectTest {

    public static void main(String[] args) {

        // 1.声明Shape类型的引用指向Shape类型的对象并打印特征
        Shape s1 = new Shape(1, 2);
        // 当Rect类中没有重写show方法时，下面调用Shape类中的show方法
        // 当Rect类中重写show方法后，下面调用Shape类中的show方法
        s1.show(); // 1 2

        // 使用ctrl+d快捷键可以复制当前行
        System.out.println("------------------------------------");
        // 2.声明Rect类型的引用指向Rect类型的对象并打印特征
        Rect r1 = new Rect(3, 4, 5, 6);
        // 当Rect类中没有重写show方法时，下面调用Shape类中的show方法
        // 当Rect类中重写show方法后，下面调用Rect类中的show方法
        r1.show(); // 3 4 5 6

        // 使用alt+shift+上下方向键  可以移动代码
        System.out.println("------------------------------------");
        // 3.声明Shape类型的引用指向Rect类型的对象并打印特征
        // 相当于从Rect类型到Shape类型的转换  也就是子类到父类的转换   小到大的转换  自动类型转换
        Shape sr = new Rect(7, 8, 9, 10);
        // 当Rect类中没有重写show方法时，下面调用Shape类中的show方法
        // 当Rect类中重写show方法后，下面的代码在编译阶段调用Shape类的方法，在运行阶段调用Rect类中的show方法
        sr.show(); // 7 8 9 10

        System.out.println("------------------------------------");
        // 4.测试Shape类型的引用能否直接调用父类和子类独有的方法呢？？？
        int ia = sr.getX();
        System.out.println("获取到的横坐标是：" + ia); // 7
        //sr.getLen();  error  Shape类中找不到getLen方法，也就是还在Shape类中查找

        // 调用静态方法
        sr.test(); // 提示：不建议使用引用.的方式访问
        Shape.test(); // 推荐使用类名.的方式访问

        System.out.println("------------------------------------");
        // 5.使用父类类型的引用调用子类独有方法的方式
        // 相当于从Shape类型到Rect类型的转换，也就是父类到子类的转换  大到小的转换   强制类型转换
        int ib = ((Rect) sr).getLen();
        System.out.println("获取到的长度是：" + ib); // 9

        // 希望将Shape类型转换为String类型  强制类型转换要求必须拥有父子类关系
        //String str1 = (String)sr;  Error
        // 希望将Shape类型强制转换为Circle类型，下面没有报错
        //Circle c1 = (Circle)sr; // 编译ok，但运行阶段发生  ClassCastException类型转换异常

        // 在强制类型转换之前应该使用instanceof进行类型的判断
        // 判断sr指向堆区内存中的对象是否为Circle类型，若是则返回true，否则返回false
        if(sr instanceof Circle) {
            System.out.println("可以放心地转换了！");
            Circle c1 = (Circle)sr;
        } else {
            System.out.println("强转有风险，操作需谨慎！");
        }
    }
}

多态的特点

• 当父类类型的引用指向子类类型的对象时，父类类型的引用可以直接调用父类独有的方法。
• 当父类类型的引用指向子类类型的对象时，父类类型的引用不可以直接调用子类独有的方法。
• 对于父子类都有的非静态方法来说，编译阶段调用父类版本，运行阶段调用子类重写的版本（动态绑定）。
• 对于父子类都有的静态方法来说，编译和运行阶段都调用父类版本。
引用数据类型之间的转换
• 引用数据类型之间的转换方式有两种：自动类型转换 和 强制类型转换。
• 自动类型转换主要指小类型向大类型的转换，也就是子类转为父类，也叫做向上转型。
• 强制类型转换主要指大类型向小类型的转换，也就是父类转为子类，也叫做向下转型或显式类型转换。
• 引用数据类型之间的转换必须发生在父子类之间，否则编译报错。
引用数据类型之间的转换
• 若强转的目标类型并不是该引用真正指向的数据类型时则编译通过，运行阶段发生类型转换异常。
• 为了避免上述错误的发生，应该在强转之前进行判断，格式如下： if(引用变量 instanceof 数据类型) 判断引用变量指向的对象是否为后面的数据类型 
package com.lagou.task09;

public class Circle extends Shape {
    private int ir;

    public Circle() {
    }

    public Circle(int x, int y, int ir) {
        super(x, y);
        setIr(ir);
    }

    public int getIr() {
        return ir;
    }

    public void setIr(int ir) {
        if (ir > 0) {
            this.ir = ir;
        } else {
            System.out.println("半径不合理哦！！！");
        }
    }

    @Override
    public void show() {
        super.show();
        System.out.println("半径是：" + getIr());
    }
}

多态的实际意义

• 多态的实际意义在于屏蔽不同子类的差异性实现通用的编程带来不同的效果。 
package com.lagou.task09;

public class ShapeTest {

    // 自定义成员方法实现将参数指定矩形对象特征打印出来的行为，也就是绘制图形的行为
    // Rect r = new Rect(1, 2, 3, 4);
//    public static void draw(Rect r) {
//        r.show(); // 1 2 3 4
//    }
    // 自定义成员方法实现将参数指定圆形对象特征打印出来的行为
//    public static void draw(Circle c) {
//        c.show(); // 5 6 7
//    }
    // 自定义成员方法实现既能打印矩形对象又能打印圆形对象的特征，对象由参数传入  子类 is a 父类
    // Shape s = new Rect(1, 2, 3, 4);   父类类型的引用指向子类类型的对象，形成了多态
    // Shape s = new Circle(5, 6, 7);    多态
    // 多态的使用场合一：通过参数传递形成了多态
    public static void draw(Shape s) {
        // 编译阶段调用父类的版本，运行阶段调用子类重写以后的版本
        s.show();
    }

    public static void main(String[] args) {

        // Rect r = new Rect(1, 2, 3, 4);
        // r.show();
        ShapeTest.draw(new Rect(1, 2, 3, 4));
        ShapeTest.draw(new Circle(5, 6, 7));
    }
}

第二节：抽象类（重点）

抽象方法的概念
• 抽象方法主要指不能具体实现的方法并且使用abstract关键字修饰，也就是没有方法体。
• 具体格式如下：
访问权限 abstract 返回值类型 方法名(形参列表); public abstract void cry(); 
package com.lagou.task09;

public abstract class AbstractTest {
    private int cnt;

    public AbstractTest() {
    }

    public AbstractTest(int cnt) {
        setCnt(cnt);
    }

    public int getCnt() {
        return cnt;
    }

    public void setCnt(int cnt) {
        this.cnt = cnt;
    }

    // 自定义抽象方法
    public abstract void show();

    public static void main(String[] args) {

        // 声明该类类型的引用指向该类类型的对象
        //AbstractTest at = new AbstractTest();
        //System.out.println("at.cnt = " + at.cnt); // 0
    }
}

抽象类的概念

• 抽象类主要指不能具体实例化的类并且使用abstract关键字修饰，也就是不能创建对象。
抽象类和抽象方法的关系
• 抽象类中可以有成员变量、构造方法、成员方法；
• 抽象类中可以没有抽象方法，也可以有抽象方法；
• 拥有抽象方法的类必须是抽象类，因此真正意义上的抽象类应该是具有抽象方法并且使用abstract关键字修饰的类。
抽象类的实际意义
• 抽象类的实际意义不在于创建对象而在于被继承。
• 当一个类继承抽象类后必须重写抽象方法，否则该类也变成抽象类，也就是抽象类对子类具有强制性和规范性，因此叫做模板设计模式。 
package com.lagou.task09;

public class SubAbstractTest extends AbstractTest/*, Account*/ {
    @Override
    public void show() {
        System.out.println("其实我是被迫重写的，否则我也得变成抽象的呀！");
    }

    public static void main(String[] args) {

        // 1.声明本类类型的引用指向本类类型的对象，没有多态
        SubAbstractTest sat = new SubAbstractTest();
        sat.show();

        System.out.println("-------------------------------");
        // 2.声明AbstractTest类型的引用指向子类的对象，形成了多态
        // 多态的使用场合之二： 直接在方法体中使用抽象类的引用指向子类类型的对象
        AbstractTest at = new SubAbstractTest2();
        // 编译阶段调用父类版本，运行阶段调用子类版本
        at.show();
        ((SubAbstractTest2) at).test();

        System.out.println("-------------------------------");
        SubAbstractTest2 sat2 = new SubAbstractTest2();
        sat2.test();
    }
}

开发经验分享

• 在以后的开发中推荐使用多态的格式，此时父类类型引用直接调用的所有方法一定是父类中拥有的方法，若以后更换子类时，只需要将new关键字后面的子类类型修改而其它地方无需改变就可以立即生效，从而提高了代码的可维护性和可扩展型。
• 该方式的缺点就是：父类引用不能直接调用子类独有的方法，若调用则需要强制类型转换。 
package com.lagou.task09;

public class SubAbstractTest2 extends AbstractTest {
    @Override
    public void show() {
        System.out.println("使用多态方式可以提高代码的可维护性哦！");
    }

    public void test() {
        System.out.println("第二个子类中独有的方法！");
    }
}

抽象类的应用及笔试考点

• 银行有 定期账户和活期账户。继承自 账户类。账户类中：
• public class Account{
private double money;
public double getLixi(){}
} 
package com.lagou.task09;

public /*final*/ abstract class Account {
    private int money;

    public Account() {
    }

    public Account(int money) {
        setMoney(money);
    }

    public int getMoney() {
        return money;
    }

    public void setMoney(int money) {
        if (money >= 0) {
            this.money = money;
        } else {
            System.out.println("金额不合理哦！！！");
        }
    }

    // 自定义抽象方法实现计算利息并返回的功能描述
    public abstract double getLixi();
    // private 和 abstract 关键字不能共同修饰一个方法
    //private abstract double getLixi();
    // final 和 abstract 关键字不能共同修饰一个方法
    //public final abstract double getLixi();
    // static 和 abstract 关键字不能共同修饰一个方法
    //public static abstract double getLixi();
}

package com.lagou.task09;

public class FixedAccount extends Account {
    public FixedAccount() {
    }

    public FixedAccount(int i) {
        super(i); // 表示调用父类的有参构造方法
    }

    @Override
    public double getLixi() {
        // 利息 = 本金 * 利率 * 时间
        return getMoney() * 0.03 * 1;
    }

    public static void main(String[] args) {

        // 1.声明Account类型的引用指向子类类型的对象，形成了多态
        //Account acc = new FixedAccount(1000);
        Account acc = new FixedAccount();
        acc.setMoney(1000);
        double res = acc.getLixi();
        System.out.println("计算的利息是：" + res); // 30.0
    }
}

第三节：接口（重点）

接口的基本概念
• 接口就是一种比抽象类还抽象的类，体现在所有方法都为抽象方法。
• 定义类的关键字是class，而定义接口的关键字是interface。
• 如： 金属接口 货币接口 黄金类 
package com.lagou.task09;

public interface InterfaceTest {
    /*public static final */int CNT = 1;  // 里面只能有常量
    //private void show(){}  // 从Java9开始允许接口中出现私有方法
    /*public abstract */void show();         // 里面只能有抽象方法（新特性除外），注释中的关键字可以省略，但建议写上
}

package com.lagou.task09;

public interface Metal {

    // 自定义抽象方法描述发光的行为
    public abstract void shine();
}

package com.lagou.task09;

public interface Money {

    // 自定义抽象方法描述购物的行为
    public abstract void buy();
}

package com.lagou.task09;

// 使用implements关键字表达实现的关系，支持多实现
public class Gold implements Metal, Money {
    @Override
    public void shine() {
        System.out.println("发出了金黄色的光芒...");
    }

    @Override
    public void buy() {
        System.out.println("买了好多好吃的...");
    }

    public static void main(String[] args) {

        // 1.声明接口类型的引用指向实现类的对象，形成了多态
        Metal mt = new Gold();
        mt.shine();

        Money mn = new Gold();
        mn.buy();
    }
}

练习题目

• 编程实现Runner接口，提供一个描述奔跑行为的抽象方法。
• 编程实现Hunter接口继承Runner接口，并提供一个描述捕猎行为的抽象方法。
• 编程实现Man类实现Hunter接口并重写抽象方法，在main方法中使用多态方式测试。 
package com.lagou.task09;

public interface Runner {
    // 自定义抽象方法描述奔跑的行为
    public abstract void run();
}

package com.lagou.task09;

// 接口只能继承接口，不能继承类
public interface Hunter extends Runner {
    // 自定义成员方法描述捕猎的行为
    public abstract void hunt();

    // 将两个默认方法中重复的代码可以提取出来打包成一个方法在下面的两个方法中分别调用即可
    private void show() {
        System.out.println("在以后的开发中尽量减少重复的代码，也就是减少代码的冗余！");
    }
    // 增加一个抽象方法
    //public abstract void show1();
    // 增加非抽象方法
    public default void show1() {
        show();
        //System.out.println("在以后的开发中尽量减少重复的代码，也就是减少代码的冗余！");
        System.out.println("show1方法中：这里仅仅是接口中的默认功能，实现类可以自由选择是否重写！");
    }

    // 增加非抽象方法
    public default void show2() {
        show();
        //System.out.println("在以后的开发中尽量减少重复的代码，也就是减少代码的冗余！");
        System.out.println("show2方法中：这里仅仅是接口中的默认功能，实现类可以自由选择是否重写！");
    }

    // 增加静态方法 隶属于类层级，也就是接口层级
    public static void test() {
        System.out.println("这里是静态方法，可以直接通过接口名.的方式调用，省略对象的创建");
    }


}

package com.lagou.task09;

public class Man implements Hunter {
    @Override
    public void hunt() {
        System.out.println("正在追赶一直小白兔...");
    }

    @Override
    public void run() {
        System.out.println("正在被一直大熊追赶，玩命奔跑中...");
    }

    @Override
    public void show1() {
        System.out.println("为了给你几分薄面，我决定重写一下！");
    }

    public static void main(String[] args) {

        // 1.声明接口类型的引用指向实现类的对象，形成了多态
        Runner runner = new Man();
        runner.run();

        Hunter hunter = new Man();
        hunter.hunt();

        System.out.println("-----------------------------------------");
        // 2.可以使用接口名称.的方式调用接口中的静态方法
        Hunter.test();
    }
}

类和接口之间的关系

抽象类和接口的主要区别（笔试题）
• 定义抽象类的关键字是abstract class，而定义接口的关键字是interface。
• 继承抽象类的关键字是extends，而实现接口的关键字是implements。
• 继承抽象类支持单继承，而实现接口支持多实现。
• 抽象类中可以有构造方法，而接口中不可以有构造方法。
• 抽象类中可以有成员变量，而接口中只可以有常量。
抽象类和接口的主要区别
• 抽象类中可以有成员方法，而接口中只可以有抽象方法。
• 抽象类中增加方法时子类可以不用重写，而接口中增加方法时实现类需
要重写（Java8以前的版本）。
• 从Java8开始增加新特性，接口中允许出现非抽象方法和静态方法，但非
抽象方法需要使用default关键字修饰。
• 从Java9开始增加新特性，接口中允许出现私有方法。

 

Andy393939
关注
专栏目录
java的学习--第七章多态和接口
Ysuhang的博客
06-18 413
实现程序设计的开-闭原则，对扩展开放，对修改关闭实例:主人喂养宠物 3.1.4向上转型/向下转型 向上转型：⽗类引⽤⼦类对象（⾃动成⽴，缺点是失去调⽤⼦类独有⽅法的能⼒）向下转型：⼦类引⽤⽗类对象（强制转换，慎重） ，需要使用instanceof进行类型判断 3.2抽象类 3.2.1概念 3.2.2抽象类和抽象方法的定义 抽象类的存在不是为了创建对象，是为了让子类继承用的。抽象类：使用abstract关键字修饰的类。 抽象方法： 使用abstract关键字修饰的方
Day7_25 Java学习之static与多态
weixin_43717536的博客
07-25 483
解析1.在类中，使用static修饰符修饰的属性（成员变量）称为静态变量，也可以称为类变量2.常量称为静态常量，方法称为静态方法或类方法，它们统称为静态成员，归整个类所有。3.静态成员不依赖于类的特定实例，被类的所有实例共享，就是说static修饰的方法或者变量不需要依赖于对象来进行访问，只要这个类被加载，Java虚拟机就可以根据类名找到它们。4.调用静态成员的语法格式类名.静态成员特别注意1、static修饰的成员变量和方法，从属于类。2、普通变量和方法从属于对象。解析1.解析。...
7、Java SE基础-多态和特殊类
weixin_42749734的博客
09-28 199
1、多态 概念： • 多态主要指同一种事物表现出来的多种形态。 • 饮料：可乐、雪碧、红牛、脉动、… • 宠物：猫、狗、鸟、小强、鱼、… • 人：学生、教师、工人、保安、… • 图形：矩形、圆形、梯形、三角形、… 多态的语法格式 • 父类类型 引用变量名 = new 子类类型(); Shape sr = new Rect(); sr.show(); 多态的特点 • 当父类类型的引用指向子类类型的对象时，父类类型的引用可以直接调 用父类独有的方法。 • 当父类类型的引用指向子类类型的对象时，父类类型的引用不
java基本数据类型_java笔记.基础篇.基本数据类型
weixin_39838362的博客
11-14 135
每种程序语言都会定义有自己的数据类型，对于java语言来说更是定义了丰富的数据类型，提供给程序员根据需求来定义变量。 java大方面共分为两种数据类型->基本数据类型和引用数据类型； 其中基本数据类型共有八种，分别是：整数(int、short、byte、long)浮点数(float、double)布尔(boolean)字符(char)，对于引用数据类型来说就是如:St...
跟着野码哥学javaDay 3
m0_74697366的博客
01-24 1034
练习1//创建一个随机数对象//开始摇号i++){//红球//去摇蓝色的//将双色球数组遍历System.out.println("本期中奖结果：");i++){练习2int x;int y;练习3System.out.println("我是无参构造，正在被调用");}*/System.out.println("品牌" + brand + "价格" + price);p.show();p.show();练习4。
定义一个描述圆的类，然后生成一个圆对象，最后输出半径、直径和面积。
先养只猫的博客
04-07 1986
可借鉴，不可抄袭！ 问题描述： 定义一个描述圆的类，名字为Circle，属性有： private double radius 方法有： double getPerimeter()，计算圆的周长 double getArea()，计算圆的面积 void disp()，输出圆的半径、周长和面积 另外，有两个构造方法： Circle()，属性半径赋值为0 Circle(double r)，属性半径赋值为r 编写main方法，从键盘输入一个小数值，作为圆的半径，并生成该对象，最后调用disp()方法，输出结果。 输
Java#抽象类和接口
qq_57272084的博客
05-08 93
在ComparableCircle类中给出接口中方法compareTo的实现体，用来比较两个圆的半径大小。定义一个测试类InterfaceTest，创建两个ComparableCircle对象，调用compareTo方法比较两个类的半径大小。若为正数，代表当前对象大；定义一个测试类InterfaceTest，创建两个ComparableCircle对象，调用compareTo方法比较两个类的半径大小。在Java中，一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类！
Java学习day01-day15学习资料
最新发布
04-05
9. **day14**: 面向对象进阶及多态，这部分可能深入到多态性，接口（Interface）和抽象类（Abstract Class）的使用，以及如何通过多态实现更灵活的设计。 10. **day15**: 继续面向对象的进阶，可能探讨了内部类...
Java入门基础学习资料day11
10-22
此java基础课程，适合0基础小白，课程一共11天课时，目录如下： day01【前言、入门程序、常量、变量】 ...JavaEE基础学习资料地址汇总：https://blog.csdn.net/weixin_46271129/article/details/133979063
Java学习day11-多态
小苏(º﹃º )的博客
12-14 1271
多态回顾今日目标1.回顾方法重写2.重写object类的equals方法3.instanceof4.多态总结：作业： 回顾 今日目标 实现方法重写 了解Object类 会使用重写实现多态机制 会使用instanceof运算符 会使用向上转型 会使用向下转型 1.回顾方法重写 1.父类的静态方法和实例方法都可以继承 2.父类的静态方法和实例方法都可以重写（覆盖）吗？ 静态方法可以被继承 不能被覆盖 public class Fu { public void a(){ System
Java面对对象编程中多态的性质
weixin_56939868的博客
02-13 140
Java面对对象编程对于多态的基本理解和阐述
Shape绘制封装基本思路：建shape（含solder、paste）然后Padstack Editor调用shape最后根据规格书绘制封装
m0_69454639的博客
10-31 481
2、Padstack Editor调用之前完成的shape来代替Padstack Editor工具没有异性图形来当做pad。（同理绘制好相应的soldermask和pastemask进行保存以便后续Padstack Editor进行调用）1、在pcb界面中新建shape symbol然后再用shape绘制好相应封装管脚的图形，完成后进行保存。3、在PCB页面上根据规格书绘制封装，保存即可完成。
Java 习题4 答案及解析
热门推荐
Rainary
06-06 9万+
问答题（1）面向对象语言有哪三个特性？ （2）类名应当遵守怎样的编程风格？ （3）变量和方法的名字应当遵守怎样的编程风格？ （4）类体内容中声明成员变量是为了体现对象的属性还是行为？ （5）类体中定义的非构造方法是为了体现对象的属性还是行为？ （6）什么时候使用构造方法？构造方法有类型吗？ （7）类中的实例变量在什么时候会被分配内存空间？ （8）什么叫方法的重载？构造方法可以重载吗？
java：try...catch跳过异常继续处理循环
清泉影月
02-27 3万+
问题描述 在代码循环体中，抛出异常后代码会停止执行，导致代码不能完整运行。 解决方案很简单，捕获异常并简单处理一下就可以。 1.捕获异常继续执行代码 只贴核心样例代码 public void getTest() { List<String> list = new ArrayList<>(); list.add("1"); li...
e.printStackTrace()
麦子的博客
08-01 1万+
catch(Exception e){ e.printStackTrace() ; } 当try语句中出现异常是时，会执行catch中的语句，java运行时系统会自动将catch括号中的Exception e 初始化，也就是实例化Exception类型的对象。e是此对象引用名称。然后e（引用）会自动调用Exception类中指定的方法，也就出现了e.printStackTrace() ;。 pri...
简单实现报异常后不退出继续执行
tyrant_800的博客
12-20 3657
数据同步，报错后重试，指定重试次数，简单代码实现 int syncTime = 1; boolean repeat = true; while ((syncTime <= 3) && repeat) { try { // 执行操作 ///////
java抛出异常后代码继续执行的情况
anne_IT_blog的博客
08-08 1万+
java抛出异常后代码继续执行的情况java抛出异常后下面的代码是否还会执行？例如下面情况public void add(int index, E element){ if(size >= elements.length) { throw new RuntimeException("顺序表已满，无法添加"); //return; //是否需要？ }
java中异常抛出后代码还会继续执行吗
dianbinzi0928的博客
09-27 3727
今天遇到一个问题，在下面的代码中，当抛出运行时异常后，后面的代码还会执行吗，是否需要在异常后面加上return语句呢？ public void add(int index, E element){ if(size >= elements.length) { throw new RuntimeException("顺序表已满，无法添加"); ...
javaSE 第九天
zgzdcxy的博客
09-17 335
  Day09 --------------------------------------------------------------------------------- 今天内容：    (1)继承    (2)访问控制    (3)final关键字    (4)对象创建的过程    (5)多态   1.继承(重中之重) 1.1 this关键字和super关键字的比...
Java学习资源：day04源代码及类文件解析
通过研究这些文件，初学者不仅能够学习到Java语言的基础知识，还能够了解到如何使用Java进行面向对象编程，包括类的创建、对象的实例化、方法的调用、属性的访问以及继承、封装、多态等核心概念。 对于Java初学者来...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Andy393939

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值