2继承&抽象类 代码块

SAP BASIS运维之三方SSL证书导入 事情的起因是我司SAP使用的SSL证书即将要到期了(上一个的SAP BASIS也辞职了),需要进行证书的更换。如上图所示,我司的证书有效期到2024年4月30日到期,需要提前预防并更换,防止过期后导致接口和访问出现问题。9.在弹出的框中,选择我们在第5个步骤中导出的转换结果存储地址,并选择导出的转换文件,点打开。12.最后一步也是关键的一步,不然就会无法更新证书,再点击左上角的个人安全环境,点另存为。10.在打开后的弹窗中,输入我们在第4个步骤中设置的密码。6.经过以上步骤后,我们获得了最终的证书文件。 阅读详情

一、继承

1.继承入门【重点】(视频01) (8‘’)
  1. 继承的概念

    让类与类之间产生关系(子父类关系),子类可以直接使用父类的非私有成员

    注意: private修饰的成员是私有成员

  2. 如何实现继承

    //格式: public class 子类名  extends 父类名{}
    
    //范例
    public class Zi extends Fu{
        
    }
    
2. 继承的特点【理解】(视频03) (5‘’)
  1. 继承的特点

    java只支持单继承,不支持多继承,但支持多层继承

    public class A {
        public void methodA(){
            System.out.println("AAA..类中的method方法");
        }
    }
    
    public class B extends A {
        public void methodB(){
            System.out.println("BBB...类中的method方法");
        }
    }
    
    public class C extends B{
    
    }
    

    注意事项 : 多层继承具有传递性,即子类同样可以直接使用爷爷类的非私有成员

    public class TestExtends {
        
        public static void main(String[] args) {
            C c = new C();
            c.methodA();
            c.methodB();
        }
        
    }
    
3. 继承中成员变量的访问特点【了解】(视频04) (6‘’)
  1. 继承中成员变量的访问

    在子类方法中访问一个变量,采用的是就近原则

    注意: 如果一定要使用父类的,可以通过super关键字,进行区分

    public class Fu {
        int a = 10;
    }
    
    public class Zi extends Fu {
    
        // 子父类当中, 出现了重名的成员变量
        int a = 20;
    
        public void method(){
    
            int a = 30;
    
            System.out.println(a);  // 30
    
            // 需求1: 在控制台打印本类成员变量 20
            System.out.println(this.a);
    
            // 需求2: 在控制台打印父类成员变量 10
            System.out.println(super.a);
        }
    }
    
自由练习-6分钟 (继承的特点,相关代码)
4. this和super访问成员的格式【】(视频05) (2‘’)
  1. this和super访问成员的格式

    this : 代表本类对象的引用

    super : 代表父类对象的引用

    关键字成员变量成员方法构造方法
    thisthis.成员变量this.成员方法()this(…)
    supersuper.成员变量super.成员方法()super(…)
5. 继承中成员方法的访问特点【】(视频06) (5‘’)
  1. 继承中成员方法的访问

    子类对象访问一个方法,同样采用的是就近原则

    注意: 如果一定要使用父类的,可以通过super关键字,进行区分

    public class Fu {
        public void show(){
            System.out.println("父类show方法");
        }
    }
    
    public class Zi extends Fu {
        public void show(){
            System.out.println("子类show方法");
        }
    
        public void method(){
            this.show();
            super.show();
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            Zi z = new Zi();
            z.method();
        }
    }
    
6. 方法重写概述和应用场景【重点】(视频07) (9‘’)
  1. 方法重写概述

    子类出现了和父类中一模一样的方法声明(方法名, 参数列表, 返回值类型 都必须一样)

      public class iPearV1 {
      
          public void smallBlack() {
              System.out.println("speak english...");
          }
          
      }
    
      public class iPearV2 extends iPearV1 {
      
          public void smallBlack(){
              System.out.println("说中文");
          }
          
      }
    
  2. 方法重写的应用场景

    在原有的功能上做扩展 :当子类需要父类的功能,而功能主体子类有自己特有内容时,可以重写父类中的方法,这 样,即沿袭了父类的功能,又定义了子类特有的内容

    public class iPearV1 {
    
        public void smallBlack() {
            System.out.println("speak english...");
        }
        
    }
    
    public class iPearV2 extends iPearV1 {
        /*
           方法重写的应用场景:
                当子类需要父类的功能,而功能主体子类有自己特有内容
                可以重写父类中的方法,这样,即沿袭了父类的功能,又定义了子类特有的内容
         */
    
        public void smallBlack(){
            super.smallBlack();
            System.out.println("说中文");
        }
    }
    
    

    完全抛弃原有功能,自己重做

    public class Fu {
    
        public void eat() {
            System.out.println("吃胡萝卜丝");
            System.out.println("吃胡萝卜叮");
            System.out.println("喝胡萝卜汤");
        }
        
    }
    
    class Zi extends Fu {
    
        public void eat() {
            System.out.println("吃牛肉");
            System.out.println("吃羊肉");
            System.out.println("喝鱼汤");
        }
    
    }
    
    class test {
        public static void main(String[] args) {
            Zi zi = new Zi();
            zi.eat();
        }
    }
    
  3. 方法重写、方法重载的区别

    方法重写: 在继承体系中, 子类出现了和父类一模一样的方法声明 (方法名, 参数列表, 返回值类型)

    方法重载: 在同一个类中, 方法名相同, 参数列表不同, 与返回值无关.

    public class TestOverload {
    	//方法重载 : 参数列表不同的三种情况
        
        //1.参数个数不同
        private void a(int a) {}
        private void a(int a, int b) {}
    
        //2.参数类型不同
        private void b(String a) {}
        private void b(int a) {}
    
        //3.参数类型不同的情况下,顺序不同
        private void c(String a, int b) {}
        private void c(int a, String b) {}
    
    }
    
7. 方法重写的注意事项【】(视频08) (9‘’)
  1. 方法重写的注意事项

    • 父类中私有方法不能被重写(父类私有成员子类是不能继承的)
    • 父类中静态方法不能被子类重写(如果子类也有一个一模一样的,并不是重写)
    • 子类重写父类方法时,访问权限必须大于等于父类(public > 默认 > 私有)
  2. Override注解

    用来检测当前的方法,是否是重写的方法,起到【校验】的作用

    public class Fu {
        public static void show(){
            System.out.println("Fu...");
        }
    
        void method(){
            System.out.println("Fu...method");
        }
    }
    
    public class Zi extends Fu {
        //@Override   静态方法不能被子类重写
        public static void show() {
            System.out.println("Zi...");
        }
    
        @Override  // 注解: 检查当前的方法是否是一个正确的重写方法
        public void method() {
            
        }
    }
    
自由练习-8分钟(方法重写应用场景)
8. 权限修饰符【了解】(视频09) (7‘’)
  1. 权限修饰符

    修饰符同一个类中同一个包中不同包的子类不同包的无关类
    private√
    默认√√
    protected√√√
    public√√√√

    常用

    private 私有的,只有本类可以访问

    public 公共的,所有类都可以访问

9. 继承中构造方法的访问特点【】(视频10) (14‘’)
  1. 继承中构造方法的访问

    子类中所有的构造方法都会默认访问父类中无参的构造方法

    为什么?

    ​ 子类在初始化的时候,有可能会使用到父类中的数据,如果父类没有初始化,子类将无法使用父类的数据

    ​ 子类初始化之前,一定要先完成父类初始化

    怎么初始化?

    ​ 构造方法的第一条语句默认都是:super()

    注意: 如果我们编写的类,没有手动指定父类,系统也会自动继承Object(Java继承体系中的最顶层父类)

    public class Person {
        private String name;
        private int age;
    
        public Person(){
            System.out.println("我是父类的空参数构造方法");
        }
        
        public Person(String name, int age){
            this.name = name;
            this.age = age;
            System.out.println("我是父类的带参数构造方法");
        }
    }
    
    public class Student extends Person {
        // 子类自己特有的属性.
        private int score;
    
        public Student(){
            super();
            System.out.println("我是子类的空参数构造方法..........");
        }
    
        public Student(String name, int age, int score){
            super(name,age);
            this.score = score;
            System.out.println("我是子类的带参数构造方法!!!");
        }
    }
    
10. 构造方法的访问特点-父类没有空参构造【】(视频11) (7‘’)
  1. 父类没有空参构造方法,只有带参构造方法,子类怎么办?

    子类需要通过super,手动调用父类的带参的构造方法

    注意: this(…) super(…) 必须放在构造方法的第一行有效语句,并且二者不能共存

    public class Test2 {
        public static void main(String[] args) {
            Zi z = new Zi();
        }
    }
    
    class Fu {
        int age;
    
        //带参数构造方法
        public Fu(int age) {
            this.age = age;
        }
    }
    
    class Zi extends Fu {
    
        public Zi() {
            //this(10);
            super(10);
        }
    
        public Zi(int age) {
            super(age);
        }
    }
    
小结-继承中的构造方法

子类中所有的构造方法都会默认访问父类中无参的构造方法

如果父类没有空参构造方法,子类需要通过super,手动调用父类的带参的构造方法

(注意:实际企业开发中,要保证每一个类都有无参构造)

11.继承的好处和弊端【了解】(视频02) (7‘’)
  1. 继承的好处

    提高了代码的复用性

    提高了代码的维护性

    让类与类之间产生了关系,是多态的前提

  2. 继承的弊端

    继承是入侵性的

    降低了代码的灵活性

    ​ 继承关系,导致子类必须拥有父类非私有属性和方法,让子类自由的世界中多了些约束

    增强了代码的耦合性

    ​ 代码与代码之间存在关联都可以将其称之为”耦合“

在这里插入图片描述

  1. 什么时候去使用继承

    当类与类之间,存在相同(共性)的内容,并且产生了is a 的关系,就可以考虑使用继承,来优化代码

    举例:

    ​ 学生: 姓名,年龄 项目经理: 姓名,工号,工资

    ​ 老师: 姓名,年龄 程序员: 姓名,工号,工资


    ​ 人 : 姓名,年龄 员工: 姓名,工号,工资

12. 代码优化和内存图解【】(视频12) (8‘’)
  1. 继承内存图解

    对象在堆内存中,会单独存在一块super区域,用来存放父类的数据
    在这里插入图片描述

13. 黑马信息管理系统-继承改进【】(视频13) (12‘’)
  • 代码图
    在这里插入图片描述

  • 把学生类和老师类共性的内容向上抽取,抽取到出一个 Person 父类,让学生类和老师类继承 Person 类

    //Person 类
    
    public class Person {
        private String id;
        private String name;
        private String age;
        private String birthday;
    
        public Person() {
        }
    
        public Person(String id, String name, String age, String birthday) {
            this.id = id;
            this.name = name;
            this.age = age;
            this.birthday = birthday;
        }
    
        public String getId() {
            return id;
        }
    
        public void setId(String id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getAge() {
            return age;
        }
    
        public void setAge(String age) {
            this.age = age;
        }
    
        public String getBirthday() {
            return birthday;
        }
    
        public void setBirthday(String birthday) {
            this.birthday = birthday;
        }
    }
    
    //Student类
    
    public class Student extends Person {
        public Student() {
        }
    
        public Student(String id, String name, String age, String birthday) {
            super(id, name, age, birthday);
        }
    }
    
    //Teacher类
    
    public class Teacher extends Person {
        public Teacher() {
        }
    
        public Teacher(String id, String name, String age, String birthday) {
            super(id, name, age, birthday);
        }
    }
    
  • 优化StudentController类中,inputStudentInfo方法,将setXxx赋值方式,改进为构造方法初始化

    注意:直接修改这种操作方式,不符合我们开发中的一个原则

    ​ 开闭原则 ( 对扩展开放对修改关闭 ) : 尽量在不更改原有代码的前提下以完成需求

    解决:重新创建一个OtherStudentController类,编写新的inputStudentInfo方法

    ​ 在由StudentController类、OtherStudentController类,提取出一个父类BaseStudentController类

    //OtherStudentController类
    
    public class OtherStudentController extends BaseStudentController {
    
        private Scanner sc = new Scanner(System.in);
    
        // 键盘录入学生信息
        // 开闭原则: 对扩展内容开放, 对修改内容关闭
        @Override
        public Student inputStudentInfo(String id) {
            System.out.println("请输入学生姓名:");
            String name = sc.next();
            System.out.println("请输入学生年龄:");
            String age = sc.next();
            System.out.println("请输入学生生日:");
            String birthday = sc.next();
            Student stu = new Student(id,name,age,birthday);
            return stu;
        }
    }
    
    //StudentController类
    
    public class StudentController extends BaseStudentController {
    
        private Scanner sc = new Scanner(System.in);
    
        // 键盘录入学生信息
        // 开闭原则: 对扩展内容开放, 对修改内容关闭
        @Override
        public Student inputStudentInfo(String id) {
            System.out.println("请输入学生姓名:");
            String name = sc.next();
            System.out.println("请输入学生年龄:");
            String age = sc.next();
            System.out.println("请输入学生生日:");
            String birthday = sc.next();
            Student stu = new Student();
            stu.setId(id);
            stu.setName(name);
            stu.setAge(age);
            stu.setBirthday(birthday);
            return stu;
        }
    }
    
    //父类BaseStudentController
    
    public class BaseStudentController {
        // 业务员对象
        private StudentService studentService = new StudentService();
    
        private Scanner sc = new Scanner(System.in);
    
        // 开启学生管理系统, 并展示学生管理系统菜单
        public final void start() {
            //Scanner sc = new Scanner(System.in);
            studentLoop:
            while (true) {
                System.out.println("--------欢迎来到 <学生> 管理系统--------");
                System.out.println("请输入您的选择: 1.添加学生  2.删除学生  3.修改学生  4.查看学生  5.退出");
                String choice = sc.next();
                switch (choice) {
                    case "1":
                        // System.out.println("添加");
                        addStudent();
                        break;
                    case "2":
                        // System.out.println("删除");
                        deleteStudentById();
                        break;
                    case "3":
                        // System.out.println("修改");
                        updateStudent();
                        break;
                    case "4":
                        // System.out.println("查询");
                        findAllStudent();
                        break;
                    case "5":
                        System.out.println("感谢您使用学生管理系统, 再见!");
                        break studentLoop;
                    default:
                        System.out.println("您的输入有误, 请重新输入");
                        break;
                }
            }
        }
    
        // 修改学生方法
        public final void updateStudent() {
            String updateId = inputStudentId();
            Student newStu = inputStudentInfo(updateId);
            studentService.updateStudent(updateId, newStu);
            System.out.println("修改成功!");
        }
    
        // 删除学生方法
        public final void deleteStudentById() {
            String delId = inputStudentId();
            // 3. 调用业务员中的deleteStudentById根据id, 删除学生
            studentService.deleteStudentById(delId);
            // 4. 提示删除成功
            System.out.println("删除成功!");
        }
    
        // 查看学生方法
        public final void findAllStudent() {
            // 1. 调用业务员中的获取方法, 得到学生的对象数组
            Student[] stus = studentService.findAllStudent();
            // 2. 判断数组的内存地址, 是否为null
            if (stus == null) {
                System.out.println("查无信息, 请添加后重试");
                return;
            }
            // 3. 遍历数组, 获取学生信息并打印在控制台
            System.out.println("学号\t\t姓名\t年龄\t生日");
            for (int i = 0; i < stus.length; i++) {
                Student stu = stus[i];
                if (stu != null) {
                    System.out.println(stu.getId() + "\t" + stu.getName() + "\t" + stu.getAge() + "\t\t" + stu.getBirthday());
                }
            }
        }
    
        // 添加学生方法
        public final void addStudent() {
            // StudentService studentService = new StudentService();
            // 1. 键盘接收学生信息
            String id;
            while (true) {
                System.out.println("请输入学生id:");
                id = sc.next();
                boolean flag = studentService.isExists(id);
                if (flag) {
                    System.out.println("学号已被占用, 请重新输入");
                } else {
                    break;
                }
            }
    
            Student stu = inputStudentInfo(id);
    
            // 3. 将学生对象,传递给StudentService(业务员)中的addStudent方法
            boolean result = studentService.addStudent(stu);
            // 4. 根据返回的boolean类型结果, 在控制台打印成功\失败
            if (result) {
                System.out.println("添加成功");
            } else {
                System.out.println("添加失败");
            }
        }
    
        // 键盘录入学生id
        public String inputStudentId() {
            String id;
            while (true) {
                System.out.println("请输入学生id:");
                id = sc.next();
                boolean exists = studentService.isExists(id);
                if (!exists) {
                    System.out.println("您输入的id不存在, 请重新输入:");
                } else {
                    break;
                }
            }
            return id;
        }
    
        // 键盘录入学生信息
        // 开闭原则: 对扩展内容开放, 对修改内容关闭
        public Student inputStudentInfo(String id){
            return null;
        }
    }
    
自由练习-10分钟

二、抽象类

1. 抽象类入门【】(视频14) (9‘’)
  1. 抽象方法

    将共性的行为(方法)抽取到父类之后,发现该方法的实现逻辑无法在父类中给出具体明确,该方法就可以定义为抽象方法

  2. 抽象类

    如果一个类中存在抽象方法,那么该类就必须声明为抽象类

  3. 抽象类和抽象方法的定义格式

    //抽象类
    public abstract class Animal {
        public void drink(){
            System.out.println("喝水");
        }
    
        public Animal(){
    		
        }
    	
        //抽象方法
        public abstract void eat();
    }
    
  4. 如何使用抽象方法

    1、继承抽象类

    2、重写抽象方法

    public class Dog extends Animal {
        @Override
        public void eat() {
            System.out.println("狗吃肉");
        }
    }
    
2. 抽象类的注意事项【】(视频15) (6‘’)
  1. 抽象类注意事项

    • 抽象类不能实例化
    • 抽象类可以有构造方法
    • 抽象类中不一定有抽象方法,有抽象方法的类一定是抽象类
    • 抽象类的子类
      • 要么重写抽象父类中所有的抽象方法
      • 要么子类本身也是一个抽象类
3.模板设计模式【】(视频16) (10‘’)
  1. 模板设计模式

    设计模式(Design pattern)是一套被反复使用,多数人知晓的,经过分类编目的,代码设计经验的总结使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性

    模板设计模式: 把抽象类整体就可以看做成一个模板,模板中不能决定的东西定义成抽象方法
    让使用模板的类(继承抽象类的类)去重写抽象方法实现需求

    小结:模板设计模式的优势,模板已经定义了通用结构,使用者只需要关心自己需要实现的功能即可

    /*
        作文模板类
     */
    public abstract class CompositionTemplate {
    
        public void write() {
            System.out.println("<<我的爸爸>>");
    
            body();
    
            System.out.println("啊~ 这就是我的爸爸");
    
        }
    
        public abstract void body();
    

}


```java
public class Tom extends CompositionTemplate {

    @Override
    public void body() {
        System.out.println("那是一个秋天, 风儿那么缠绵,记忆中, " +
                "那天爸爸骑车接我放学回家,我的脚卡在了自行车链当中, 爸爸蹬不动,他就站起来蹬...");
    }

}
自由练习-8分钟
4. final关键字【重点】(视频17) (14‘’)
  • fianl关键字概述

    final代表最终的意思,可以修饰: 类、成员方法、成员变量

  • final修饰类、成员方法、成员变量的效果

    fianl修饰类: 表示该类是最终类,不能被继承。 (不能有子类,但是可以有父类)

    final修饰方法: 表示该方法是最终方法, 不能被重写

    final修饰变量: 表明该变量是一个常量,不能再次赋值

    ​ 变量是基本类型: 数据值不能发生改变

    ​ 变量是引用类型: 地址值不能发生改变,但是地址里面的内容是可以发生改变的

  • 常量的命名规范

    如果是一个单词, 所有字母大写, 如果是多个单词, 所有字母大写, 但是中间需要使用_分隔

    public class TestFinal {
        /*
            final修饰变量:
    
                基本数据类型变量: 其值不能被更改
    
                引用数据类型变量: 地址值不能被更改, 但是可以修改对象的属性值
         */
        public static void main(String[] args) {
            // 常量的命名规范: 如果是一个单词, 所有字母大写, 如果是多个单词, 所有字母大写, 但是中间需要使用_分隔
            final int A = 10;
            // a = 10;
            final int MAX = 10;
            final int MAX_VALUE = 20;
    
            final Student stu = new Student();
            stu.setName("张三");
            stu.setName("李四");
    
            // stu = new Student();
        }
    }
    
    class Student {
        // final修饰成员变量 初始化时机
        // 1. 在创建的时候, 直接给值
        // 2. 在构造方法结束之前, 完成赋值
        final int a = 10;
    
        private String name;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    
  • String是引用类型,为什么使用fianl修饰后不能改变值呢

    String每次赋值都是创建了一个新的对象,地址值发生了改变

    public class Demo1String {
        /*
            Java程序中, 所有的双引号字符串, 都是String这个类的对象
    
            字符串是常量;它们的值在创建之后不能更改
         */
        public static void main(String[] args) {
            String s1 = "abc123";
            int length = s1.length();
            System.out.println(length);
    
            s1 = "def";  // 这一步是让s1这个字符串类型的变量, 记录了一个新的对象.
    
            System.out.println(s1);
    
        }
    }
    
5. 黑马信息管理系统-抽象类改进【】(视频18) (2‘’)
  • BaseStudentController类改为抽象类,inputStudentInfo方法改为抽象方法

  • BaseStudentController类中不需要重写的方法,使用final进行修饰

    public abstract class BaseStudentController {
        // 业务员对象
        private StudentService studentService = new StudentService();
    
        private Scanner sc = new Scanner(System.in);
    
        // 开启学生管理系统, 并展示学生管理系统菜单
        public final void start() {
            //Scanner sc = new Scanner(System.in);
            studentLoop:
            while (true) {
                System.out.println("--------欢迎来到 <学生> 管理系统--------");
                System.out.println("请输入您的选择: 1.添加学生  2.删除学生  3.修改学生  4.查看学生  5.退出");
                String choice = sc.next();
                switch (choice) {
                    case "1":
                        // System.out.println("添加");
                        addStudent();
                        break;
                    case "2":
                        // System.out.println("删除");
                        deleteStudentById();
                        break;
                    case "3":
                        // System.out.println("修改");
                        updateStudent();
                        break;
                    case "4":
                        // System.out.println("查询");
                        findAllStudent();
                        break;
                    case "5":
                        System.out.println("感谢您使用学生管理系统, 再见!");
                        break studentLoop;
                    default:
                        System.out.println("您的输入有误, 请重新输入");
                        break;
                }
            }
        }
    
        // 修改学生方法
        public final void updateStudent() {
            String updateId = inputStudentId();
            Student newStu = inputStudentInfo(updateId);
            studentService.updateStudent(updateId, newStu);
    
            System.out.println("修改成功!");
        }
    
        // 删除学生方法
        public final void deleteStudentById() {
            String delId = inputStudentId();
            // 3. 调用业务员中的deleteStudentById根据id, 删除学生
            studentService.deleteStudentById(delId);
            // 4. 提示删除成功
            System.out.println("删除成功!");
        }
    
        // 查看学生方法
        public final void findAllStudent() {
            // 1. 调用业务员中的获取方法, 得到学生的对象数组
            Student[] stus = studentService.findAllStudent();
            // 2. 判断数组的内存地址, 是否为null
            if (stus == null) {
                System.out.println("查无信息, 请添加后重试");
                return;
            }
            // 3. 遍历数组, 获取学生信息并打印在控制台
            System.out.println("学号\t\t姓名\t年龄\t生日");
            for (int i = 0; i < stus.length; i++) {
                Student stu = stus[i];
                if (stu != null) {
                    System.out.println(stu.getId() + "\t" + stu.getName() + "\t" + stu.getAge() + "\t\t" + stu.getBirthday());
                }
            }
        }
    
        // 添加学生方法
        public final void addStudent() {
            // StudentService studentService = new StudentService();
            // 1. 键盘接收学生信息
            String id;
            while (true) {
                System.out.println("请输入学生id:");
                id = sc.next();
                boolean flag = studentService.isExists(id);
                if (flag) {
                    System.out.println("学号已被占用, 请重新输入");
                } else {
                    break;
                }
            }
    
            Student stu = inputStudentInfo(id);
    
            // 3. 将学生对象,传递给StudentService(业务员)中的addStudent方法
            boolean result = studentService.addStudent(stu);
            // 4. 根据返回的boolean类型结果, 在控制台打印成功\失败
            if (result) {
                System.out.println("添加成功");
            } else {
                System.out.println("添加失败");
            }
        }
    
        // 键盘录入学生id
        public String inputStudentId() {
            String id;
            while (true) {
                System.out.println("请输入学生id:");
                id = sc.next();
                boolean exists = studentService.isExists(id);
                if (!exists) {
                    System.out.println("您输入的id不存在, 请重新输入:");
                } else {
                    break;
                }
            }
            return id;
        }
    
        // 键盘录入学生信息
        // 开闭原则: 对扩展内容开放, 对修改内容关闭
        public abstract Student inputStudentInfo(String id);
    }
    

三、代码块

1. 代码块【】(视频19) (12‘’)
  1. 代码块概述

    在Java中,使用 { } 括起来的代码被称为代码块

  2. 代码块分类

    • 局部代码块

      位置:方法中定义
      作用:限定变量的生命周期,及早释放,提高内存利用率

    • 构造代码块

      位置:类中方法外定义
      特点:每次执行构造方法时,都会执行该代码块中的代码,并且在super()语句之后执行
      作用:将多个构造方法中相同的代码,抽取到构造代码块中,提高代码的复用性

    • 静态代码块

      位置:类中方法外定义
      特点:需要通过static关键字修饰,随着类的加载而加载,并且只执行一次
      作用:在类加载的时候做一些数据初始化的操作

2. 黑马信息管理系统-代码块改进【】(视频20) (3‘’)
  • 添加静态代码块-初始化学生信息

    public class StudentDao {
        // 创建学生对象数组
        private static Student[] stus = new Student[5];
    
        static {
            Student stu1 = new Student("heima001","张三","23","1999-11-11");
            Student stu2 = new Student("heima002","李四","24","2000-11-11");
    
            stus[0] = stu1;
            stus[1] = stu2;
        }
        
    	........
    }
    
    System.out.println("您输入的id不存在, 请重新输入:");
            } else {
                break;
            }
        }
        return id;
    }
    
    // 键盘录入学生信息
    // 开闭原则: 对扩展内容开放, 对修改内容关闭
    public abstract Student inputStudentInfo(String id);
    

    }

    
    
    
最优化学习笔记1——关于拟牛顿法推导 从2020年3月份到现在,一年的时间里断断续续自学最优化,结合豆瓣读书、知乎等网站上的推荐,翻阅了以下书和课程: Stephen Boyd和Lieven Vandenberghe的《Convex Optimization》,这本书被公认为学习凸优化的必读经典著作,其中大量的篇幅讲应用,讲理论和算法的篇幅稍少一些。在B网站上有Boyd的视频课程,油管上也有,不过只有英文字幕,如果是零基础接触,直接看Boyd的视频稍显费劲,B站上也有凌青老师以《Convex Optimization》为教材的讲解,推荐作为入 阅读详情

相关推荐

115.工业相机海康SDK开发指南(阅读)

包含初始化SDK和反初始化SDK接口。(由于看不到函数内部的具体实现,因此以下的解释仅代表个人的理解)

weixin_63779802的博客 5997

抽象类的编写和继承(例题实现)

例题1,编写抽象类(动物类)Animal,该类下包括属性infor,方法eat();编写猫类(Cat)继承动物类,在该类中实现(完善)动物类的eat()方法,可以自定义一些属性和方法;编写人类(Human)继承动物类,在该类中实现(完善)动物类的eat()方法,可以自定义一些属性和方法;编写类TestX使用猫类和人类。

小牛从头学起的博客 1411

【零基础入门哈希签名架构,从Lamport到SPHINCS+】第二集 哈希签名树 Merkle Tree Authentication

在第一集中,我们一直忽略了一个问题。设想一下,假如有一个Hacker(黑客),在截获到Sender发送给Receiver的公钥之后,把这个公钥改成Hacker自己的公钥,然后再发给Receiver,那么Receiver就会误认为这是Sender的公钥。所以我们之前所说放方案,其安全性都需要建立在一个前提下:Receiver需要确认公钥确实是Sender发出的。

m0_50572808的博客 2458

java继承(抽象类)

如果多个类有共同的属性和方法,那么我们可以吧这些类中共同的属性和方法放到父类中,让这些类(子类)去继承父类,减少代码的重复性。3.一般属性用private修饰,方法用public修饰,所以我们以后开发的工作里卖,主要是继承方法的。方法重写:在继承或者实现关系里面,如果子类和父类的方法名,参数列列表,返回值完全一致,就是方法重写。this() super() 代表调用构造方法,并且只能在构造方法里面被调用。面向过程 : C语言,以方法为主体,所有的功能都是通过方法之间的调用完成的。一般只在构造方法里面。

weixin_65011388的博客 1301

实战解析:利用Wireshark解密QQ通信协议

本文提供了一份利用Wireshark工具分析QQ通信协议的实战指南。文章详细介绍了从环境准备、捕获数据包到解析协议层的完整流程,重点演示了如何识别QQ号码字段、观察加密数据特征以及区分不同通信类型(如文本、文件传输)。通过此实践,读者可以深入理解网络分层模型和现代应用加密通信机制,提升网络协议分析与安全诊断能力。

weixin_29210727的博客 413

Zynq7020实战:ARM Cortex-A9降频避坑指南(附温度对比测试)

本文详细介绍了如何在Zynq7020平台上对ARM Cortex-A9处理器进行降频优化,以降低功耗并提升系统稳定性。通过分析时钟架构、提供实战操作步骤和温度对比测试数据,帮助开发者有效避免降频过程中的常见问题,实现嵌入式系统的高效能耗管理。

root9的博客 207

Java新手:static、代码块、继承、抽象类

static 关键字 static是静态修饰符,一般用来修饰类中的成员变量和成员方法。 被static修饰的成员变量属于类,不属于这个类的某个对象,多个对象共享同一个static成员变量。 被static修饰的成员可以通过类名直接访问,格式是:类名.静态成员变量名,类名.静态成员方法名() 静态的加载优先于对象,随着类的加载而加载。 public class StaticDemo { pu...

java新手的博客 699

基于YOLOv8/YOLOv7/YOLOv6/YOLOv5的商品识别系统(深度学习+UI界面+训练数据集+Python代码)

随着新零售和智能仓储的快速发展,商品识别技术成为计算机视觉领域的重要研究方向。本文详细介绍了基于YOLO系列算法的商品识别系统的完整实现方案,涵盖算法原理、数据集构建、模型训练、系统集成和可视化界面开发。通过对比YOLOv5到YOLOv8各版本性能差异,我们构建了一个高效、准确且用户友好的商品识别系统,并提供完整的代码实现。

YOLO 288

JavaSE进阶笔记-继承

1. 继承 1.1 继承的实现(掌握) 继承的概念 继承是面向对象三大特征之一,可以使得子类具有父类的属性和方法,还可以在子类中重新定义,以及追加属性和方法 实现继承的格式 继承通过extends实现 格式:class 子类 extends 父类 { } 举例:class Dog extends Animal { } 继承带来的好处 继承可以让类与类之间产生关系,子父类关系,产生子父类后,子类则可以使用父类中非私有的成员。 示例代码 public class Fu {

SUIT THUG!的博客 387

OpenOCD入门到精通:第28章 综合实战:RISC-V 调试

RISC-V调试实战摘要 本文介绍了RISC-V调试规范及其在OpenOCD中的实现。主要内容包括: RISC-V Debug规范的两个版本(0.11和0.13)及其差异,OpenOCD通过自动检测DTMCS寄存器版本号选择对应驱动实现。 RISC-V调试架构的分层设计,包含DTM、Debug Module、Program Buffer等核心组件,以及三种内存访问方式(progbuf、sysbus、abstract)。 以GD32VF103为例的实战调试配置,包括硬件连接、OpenOCD配置文件编写和GDB

从事嵌入式linux android驱动开发,拥有全栈能力 285

程序化广告ADX系统架构设计与实现

摘要: 本文详细介绍了程序化广告交易平台(ADX)的系统架构设计与实现。ADX作为连接广告主与媒体的核心平台,采用基于腾讯云和阿里云的微服务架构,包含网络基础设施、负载均衡、消息处理、核心业务服务和多级数据存储等层次。重点解析了Kafka消息队列处理高并发广告请求、Redis实时统计关键指标等核心技术实现,并提供了Java代码示例展示广告请求处理、竞价流程等核心功能。该系统通过分层设计和分布式组件,实现了高性能、高可用的程序化广告交易能力。

私聊前往站内信:https://i.youkuaiyun.com/#/msg/chat/weixin_44976692 773

12-Java 继承&&抽象类&&代码块(详解~)

​当我们在做子类共性功能抽取时,有些方法在父类中并没有具体的体现,这个时候就需要抽象类了!​在Java中,一个没有方法体的方法应该定义为抽象方法,而类中如果有抽象方法,该类必须定义为抽象类!在Java中,使用{}括起来的代码被称为代码块。...

一颗西柚的博客 692

2026 年 AI 大模型资讯深度研究报告 / 2026 年 3 月 11 日

2026 年已成为 AI 大模型发展的关键拐点年。从 2023 年 ChatGPT 开启的技术奇点,历经多模态突破、推理能力崛起,至 2025 年形成产业爆发态势,AI 大模型正从"技术验证期"迈向"产业落地期"。核心发现技术突破: OpenAI 于 2026 年 3 月 6 日发布 GPT-5.4,首次实现原生计算机操控能力,在 OSWorld 桌面操控测试中以 75% 成功率超越人类 (72.4%),标志着 AI 从"对话工具"向"自主数字员工"的时代跃迁市场格局。

AI天才研究院 791

DAY05_面向对象高级(2)&继承&抽象类&代码块

继承,权限修饰符,super,方法重写,抽象类,final,局部代码块、构造代码块、静态代码块,信息管理系统使用所学技术进行优化代码

m0_57075290的博客 136

RU DOS版、EFI版32bit/64bit BIOS常用工具

DOS版、EFI版的RU工具,可用来查看IO、MEM、PCI、SMBIOS等资源。亲测在EFI SHELL下可用。

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

Java 继承&抽象类习题答案

基础题目 第一题:概念辨析 1. 什么叫做类与类的继承,作用是什么? 就是子类继承父类的属性和行为,使得子类对象具有与父类相同的属性、相同的行为。 作用是子类复用父类内容。 继承后,父类与子类之间,各成员有什么样的影响? 成员变量: 不重名,没有影响。 重名,就近使用,使用super区分父类变量。 构造方法: 无影响,但是子类构造方法默认调用父类构造方法 成员方法: 不重名,...

kai46385076的专栏 8495

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

JAVA练习题之继承&抽象类

开始之前先温习一下继承和抽象类的一些基本概念。

m0_71663894的博客 1696

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

Java知识【抽象类&代码块】

抽象类,代码块

日常学习总结 503

Java基础&面向对象&继承&抽象类

本篇文章介绍了java中的面向对象和继承以及抽象类

莫等闲 白了少年头 空悲切 1640

【Java】抽象类&继承的综合案例

抽象类、继承的综合案例

少年你真的要止步于此嘛。 1439

继承&抽象&代码块

继承 概念 Java继承通过关键字extends实现 是面向对象三大特性之一(封装、继承、多态) 被继承的类称为父类 实现继承的类称为子类 特点 子类可以直接使用父类中非私有成员 Java只支持单继承,不支持多继承,但是java可以多层继承 例如:B继承A,C继承B,那么C也可以拥有A的共有属性 其中成员变量和成员方法的访问特点是基于就近原则 public Class A { int num = 18; } public Class B extends A { int num = 2

weixin_44420698的博客 162

JavaSE进阶_02_继承&抽象类&代码块

今日内容 ​ 继承 【重点】 ​ 抽象类 【重点】 ​ final关键字 【重点】 ​ 代码块 【重点】 继承(extends) 【重点】 什么是继承 ​ 继承是面向对象的三大特征(封装、继承和多态)之一 ​ 使用extends关键字使类与类之间产生关系(子父类关系) ​ 子类可以拥有父类中的成员(除了私有的和构造方法之

mxyjajajavavava的博客 213

继承&抽象类习题

# 基础题目 ## 第一题:概念辨析 1. 什么叫做类与类的继承,作用是什么? * 就是子类继承父类的属性和行为,使得子类对象具有与父类相同的属性、相同的行为。 * 作用是子类复用父类内容。 2. 继承后,父类与子类之间,各成员有什么样的影响? * 成员变量: * 不重名,没有影响。 * 重名,就近使用,使用super区分父类变量。 * 构造方法: * 无影响,但是子类构造方法默认调用父类构造方法 * 成员方法: * 不重名,没有影...

guanghuotainkong的博客 1659

python中的抽象类及多继承

一、抽象类 之前我们定义了Person类实现了eat()、sleep()方法, 每种人都会吃喝但是吃喝的地点不同,如果实现了方法体就浪费了。因此我们可以只定义eat()方法,不实现方法体,这种形式我们可以将方法定义为抽象方法,具有抽象方法的类就叫做抽象类。 抽象类是一个特殊的类,只能被继承,不能实例化,抽象类中可以有抽象方法和普通方法。 (1) .定义抽象类 定义抽象类需要导入 abc模块。 fr...

李嘉豪的博客 2697

09--继承类&抽象类

第一题 什么叫做类与类的继承,作用是什么? 就是子类继承父类的属性和行为,使得子类对象具有与父类相同的属性、相同的行为。 作用是子类复用父类内容。 继承后,父类与子类之间,各成员有什么样的影响? 成员变量: 不重名,没有影响。 重名,就近使用,使用super区分父类变量。 构造方法: 无影响,但是子类构造方法默认调用父类构造方法 成员方法: 不重名,没有影响。 重名,子类重写父类方法。 子类中,如何调用父类的成员?如何使用本类的成员? 父类

qq_44787898的博客 609

权限修饰符,代码块,抽象类,接口.Java

🍑我们之前学过什么是类,那么抽象类是不是也是类的一种呢?听名字就感觉好抽象呀!说对了,他就是抽象的,不是具体的。在类中没有包含足够的信息来描绘一个具体的对象,这样的类称为抽象类。🌰来看一个抽象类的例子// 抽象类和抽象方法需要被 abstract 关键字修饰// 抽象类中的方法一般要求都是抽象方法,抽象方法没有方法体大家觉得这个抽象类是不是什么也没干,他唯一的方法draw()还是空的。像这样的类是不是就没有包含足够的信息来描绘一个具体的对象,自然也就不能实例化对象了。

2301_80250542的博客 932

抽象类和多重继承

抽象类和多重继承 一. 引言 图形的面积如何计算? 在现实生活中需要知道具体的图形才能求面积 问题:shape类有必要存在么? 二. 抽象类 面向对象中的抽象类 可用于表示现实世界中的抽象概念 是一种只能定义类型,而不能产生对象的类 只能被继承并且重写相关函数 直接特征是相关函数没有完整的实现 Shape是现实世界中各个图形的抽象概念 程序中必须能够反映抽象的图形 程序中通过抽象类表示图形的概念 抽象类不能创建对象,只能用于继承 三. 抽象类与纯虚函数 C++中没有抽象类的概念 C++中通过纯虚函

Andrea-地面宇航员 1038
上一篇: 1分类和static 分包思想
下一篇: 3接口&多态
InLoadwetrust
博客等级 码龄6年 11粉丝 84原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

InLoadwetrust

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

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

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

打赏作者

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

抵扣说明:

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

余额充值