3接口&多态

4. PCIe 接口时序 在上一篇中,大致介绍IPcore接口。总的来说接口如下图数据的接收和发送通过transmitTLPinterface和ReceiveTLPinterface。收发数据的时序也只是描述这几个接口的关系。从手册上截取PCIex1的接口时序。 阅读详情

JavaSE进阶-day03

一、接口

1.黑马信息管理系统-集合改进【】(视频01) (10‘’)
  • 使用数组容器的弊端

1.容器长度是固定的,不能根据添加功能自动增长

2.没有提供用于赠删改查的方法

  • 优化步骤

    1.创建新的StudentDao类,OtherStudentDao

    2.创建ArrayList集合容器对象

    3.OtherStudentDao中的方法声明,需要跟StudentDao保持一致

    ​ 注意:如果不一致,StudentService中的代码就需要进行修改。

    4.完善方法(添加、删除、修改、查看)

    5.替换StudentService中的Dao对象

  • 集合转换成数组的方法

    Student[] students = new Student[stus.size()];
    stus.toArray(students);
    
  • 代码流程图

在这里插入图片描述

  • OtherStudentDao类

    /**
     * 开闭原则: 对扩展开放、对修改关闭
     *
     *
     * 低耦合
     */
    public class OtherStudentDao {
        // 集合容器
        private static ArrayList<Student> stus = new ArrayList<>();
    
        static {
            Student stu1 = new Student("heima001","张三","23","1999-11-11");
            Student stu2 = new Student("heima002","李四","24","2000-11-11");
    
            stus.add(stu1);
            stus.add(stu2);
        }
    
        // 添加学生方法
        public boolean addStudent(Student stu) {
           stus.add(stu);
           return true;
        }
    
        // 查看学生方法
        public Student[] findAllStudent() {
            Student[] students = new Student[stus.size()];
            stus.toArray(students);
            return students;
        }
    
        public void deleteStudentById(String delId) {
            // 1. 查找id在容器中所在的索引位置
            int index = getIndex(delId);
            stus.remove(index);
        }
    
        public int getIndex(String id){
            int index = -1;
            for (int i = 0; i < stus.size(); i++) {
                Student stu = stus.get(i);
                if(stu != null && stu.getId().equals(id)){
                    index = i;
                    break;
                }
            }
            return index;
        }
    
        public void updateStudent(String updateId, Student newStu) {
            // 1. 查找updateId, 在容器中的索引位置
            int index = getIndex(updateId);
            stus.set(index, newStu);
        }
    }
    
2.黑马信息管理系统-抽取公共Dao【】(视频02) (6‘’)
  • 抽取公共Dao

    public abstract class BaseStudentDao {
        // 添加学生方法
        public abstract boolean addStudent(Student stu);
        // 查看学生方法
        public abstract Student[] findAllStudent();
        // 删除学生方法
        public abstract void deleteStudentById(String delId);
        // 根据id找索引方法
        public abstract int getIndex(String id);
        // 修改学生方法
        public abstract void updateStudent(String updateId, Student newStu);
    }
    
  • 实现继承

    public class StudentDao extends BaseStudentDao {}
    
    //快捷键 alt + insert  :  快速进行方法重写
    public class OtherStudentDao extends BaseStudentDao {}
    
3.接口介绍【】(视频03) (5‘’)
  1. 什么是接口

    接口就是一种公共的规范标准,只要符合规范标准,都可以使用

    当一个类中的所有方法都是抽象方法的时候,我们就可以将其定义为接口

  2. 接口存在的意义

    规则的定义

    程序的扩展

4.接口的定义和特点【重点】(视频04) (9‘’)
  1. 如何定义接口

    //public interface 接口名{}
    public interface Inter {
        public abstract void study();
    }
    
  2. 如何实现接口

    //public class 类名 implements 接口名{}
    public class InterImpl implements Inter {
        @Override
        public void study() {
            System.out.println("我是实现类中的study方法");
        }
    }
    
  3. 当一个类中的所有方法都是抽象方法的时候,我们就可以将其定义为接口, 为什么?

    1、接口(干爹)不占用继承(亲爹)的位置

    2、使用接口需要写的代码量少

在这里插入图片描述

  1. 接口的特点

    • 接口不能被实例化

    • 接口的实现类 : 如果实例类不是抽象类,就必须重写接口中所有的抽象方法

    • 接口和实现类关系,可以单实现,也可以多实现

    //接口
    public interface Inter {
     public abstract void study();
    }
    
    //接口
    public interface InterA {
        public abstract void print1();
        public abstract void print2();
        public abstract void study();
    }
    
    //实现类 - 必须实现接口中所有的抽象方法
    class InterImpl implements Inter{
     public void study(){}
    }
    
    //可以单实现,也可以多实现
    public class InterImpl implements Inter , InterA {
        @Override
        public void study() {
            System.out.println("我是实现类中的study方法");
        }
    
        @Override
        public void print1() {
        }
    
        @Override
        public void print2() {
        }
    }
    
自由练习-5分钟 - (接口的定义)
5.接口中的成员特点【重点】(视频05) (8‘’)
  • 成员变量

    只能是常量,默认修饰符为:public static final

    public interface Inter {
        public static final int NUM = 10;
    }
    
    public class TestInterface {
        /*
            成员变量: 只能是常量 系统会默认加入三个关键字
                        public static final
         */
        public static void main(String[] args) {
            System.out.println(Inter.NUM);
        }
    }
    
    class InterImpl implements Inter{
    
        public void method(){
            // NUM = 20;
            System.out.println(NUM);
        }
    
    }
    
  • 构造方法

    接口中没有构造方法

    public interface Inter {
        public static final int NUM = 10;
    	
        // 接口中 - 构造方法: 不存在
        // public Inter(){}
    
        public abstract void show();
    }
    
    
    class InterImpl extends Object implements Inter{
    		
        //接口实现类中,  super() 调用的是父类的构造方法(比如: Object)
        public InterImpl(){
            super();
        }
        
    }
    
  • 成员方法

    只能是抽象方法,默认修饰符为:public abstract
    注意:jdk8版本以前

    public interface Inter {
      /*
    成员方法: 只能是抽象方法, 系统会默认加入两个关键字 
                             public abstract
    
         JDK8以后可以有静态方法
         JDK9以后可以有默认方法
      */
       public abstract void show();
    }
    
6.JDK8版本中接口成员的特点-默认方法【了解】(视频06) (8‘’)
  • 默认方法的作用

    解决接口升级的问题

在这里插入图片描述

  • 默认方法的格式

    //格式:public default 返回值类型 方法名(参数列表) {}
    //注意: 默认方法只能使用 public进行修饰
    public default void show3() {   
    }
    
  • 默认方法的注意事项

  • 默认方法不是抽象方法,所以不强制被重写。但是可以被重写,重写的时候去掉default关键字
  • 如果实现了多个接口,多个接口中存在相同的方法声明,实现类就必须对该方法进行重写
  • public可以省略,default不能省略
7.JDK8版本中接口成员的特点-静态方法 【了解】(视频07) (5‘’)
  • 静态方法 - 语法格式

    //格式:public static 返回值类型 方法名(参数列表) { }
    public static void show() {
    }
    
  • 接口中静态方法的注意事项

    • 静态方法只能通过接口名调用,不能通过实现类名或者对象名调用
    • public可以省略,static不能省略
    public interface InterA {
    
        public static void show() {
        }
    
    }
    
    class InterAImpl implements InterA {
    
    }
    
    class Test {
        public static void main(String[] args) {
            InterA.show();   //可以
    
            InterAImpl.show();  //不可以
    
            InterAImpl interA = new InterAImpl();
            interA.show();  //不可以
        }
    }
    
8.JDK9版本中接口成员的特点-私有方法 【了解】(视频08) (8‘’)
  • 私有方法 - 使用格式

    //格式1:private 返回值类型 方法名(参数列表) {   }
    private void show() {  }
    
    //格式2:private static 返回值类型 方法名(参数列表) {  }
    private static void method() {  }
    
  • 接口中私有方法的注意事项

    • 私有方法是jdk9才存在的, jdk9以前接口中方法的访问权限只能是公共的
    • 静态方法只能调用静态的私有方法,不能调用普通的私有方法
9.类和接口的关系【】(视频09) (8‘’)
  1. 类和接口的关系

    • 类和类之间的关系

      继承关系 : 可以单继承,不能多继承,但是可以多层继承

      组合关系: A类中存在B类的成员变量

    • 类和接口之间的关系

      实现关系,可以单实现,也可以多实现
      还可以继承一个类的同时,再实现多个接口

      class InterImpl extends Object implements Inter{
      		
          //接口实现类中,  super() 调用的是父类的构造方法(比如: Object)
          public InterImpl(){
              super();
          }
          
      }
      
    • 接口和接口之间的关系

      继承关系,可以单继承、也可以多继承

      public interface InterC extends InterA , InterB {
      	
      }
      
    • 为什么类只能单继承 而类却可以实现多接口? 为什么接口可以多继承接口?

在这里插入图片描述

 ```java
 //为什么类却可以实现多接口?
 public interface Inter {
     public abstract void study();
 }
 
 interface InterA {
     public abstract void study();
 }
 
 class InterImpl implements Inter, InterA {
 
     @Override
     public void study() {
 
     }
 }
 ```

 ```java
 //为什么接口可以多继承接口?
 public interface InterA {
     public abstract void study();
 }
 
 interface InterB {
     public abstract void study();
 }
 
 interface InterC extends InterA, InterB {
     public abstract void study();
 }
 
 
 class D implements InterC {
     @Override
     public void study() {
 
     }
 }
 ```

 结论: 类多继承会造成逻辑冲突, 类实现多接口不会逻辑冲突,接口继承多接口也不会逻辑冲突
10.黑马信息管理系统-接口改进【】(视频10) (2‘’)
  • BaseStudentDao类改为接口

    public interface BaseStudentDao {
        // 添加学生方法
        boolean addStudent(Student stu);
    
        // 查看学生方法
        Student[] findAllStudent();
    
        // 删除学生方法
        void deleteStudentById(String delId);
    
        // 根据id找索引方法
        int getIndex(String id);
    
        // 修改学生方法
        void updateStudent(String updateId, Student newStu);
    }
    
  • 实现接口

    public class StudentDao implements BaseStudentDao {}
    
    public class OtherStudentDao implements BaseStudentDao {}
    

二、多态

1.黑马信息管理系统-多态引入【】(视频11) (6‘’)
  • 存在问题- service与dao耦合性大

    public class StudentService {
        private StudentDao studentDao = new StudentDao();
    }
    
    public class StudentService {
        private OtherStudentDao studentDao = new OtherStudentDao();
    }
    
  • 解决方案,创建工厂

    public class StudentDaoFactory {
        public static OtherStudentDao getStudentDao(){
           return new OtherStudentDao();
        }
    }
    
    public class StudentService {
        // 通过学生库管工厂类, 获取库管对象
        private OtherStudentDao studentDao = StudentDaoFactory.getStudentDao();
    }
    
2.多态的前提条件【重点】(视频12) (6‘’)
  1. 什么是多态?

    同一个对象,在不同时刻表现出来的不同形态 ( h2O 水 冰 气)

    public class Test1Polymorphic {
    	
        //同一个对象 new Cat(); 可以使用不同类型的变量引用
        public static void main(String[] args) {
            // 当前事物, 是一只猫
            Cat c = new Cat();
            
            // 当前事物, 是一只动物
            Animal a = new Cat();
            a.eat();
        }
    }
    
    class Animal {
        public void eat(){
            System.out.println("动物吃饭");
        }
    }
    
    class Cat extends Animal {
        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
    }
    
  2. 多态的前提条件有哪些?

    要有继承/实现关系
    要有方法重写
    要有父类引用指向子类对象

    //前提条件之 - 实现关系
    public interface Animal {
    }
    
    //前提条件之 - 实现关系
    public class Cat implements Animal {
    
        @Override
        public void eat() {
        }
    
        public static void main(String[] args) {
            Animal a = new Cat();
        }
    }
    
自由练习-6分钟 - (什么是多态)
3.多态中成员访问的特点 【重点】(视频13) (7‘’)
  • 成员变量

    编译看左边(父类)、运行看左边(父类)

    public class Test2Polymorpic {
        /*
             多态的成员访问特点:
                成员变量: 编译看左边 (父类), 运行看左边 (父类)
                
                编译看左边 (父类): 当父类不存在num变量时,代码编译就会报错
                运行看左边 (父类): 运行结果,10
                    
         */
        public static void main(String[] args) {
            Fu f = new Zi();
            System.out.println(f.num);
        }
    }
    
    class Fu {
        int num = 10;
    }
    
    class Zi extends Fu {
        int num = 20;
    }
    
  • 成员方法

    编译看左边(父类)、运行看右边(子类)

    前提:进行了方法重写
    静态方法本质上是没有进行重写的,编译运行都是左边
    final修饰的方法不能进行重写,编译运行都是左边
      public class Test2Polymorpic {
          /*
               多态的成员访问特点:
      			 成员方法: 编译看左边 (父类), 运行看右边 (子类)
      			 
      		     编译看左边 (父类):  父类中不存在method方法,编译就会报错
      		     运行看右边 (子类): 子类重写了父类方法,运行结果: 执行子类method方法
           */
          public static void main(String[] args) {
              Fu f = new Zi();
              f.method();
          }
      }
      
      class Fu {
          public void method(){
              System.out.println("Fu.. method");
          }
      }
      
      class Zi extends Fu {
          public void method(){
              System.out.println("Zi.. method");
          }
      }
    
4.多态的好处和弊端 【】(视频14) (9‘’)
  • 多态的好处

    提高了代码的扩展性
    定义方法时,如果将父类型作为参数,在使用方法时,可以传递任意子类对象 (重点)

    代码图:
    在这里插入图片描述

    代码实现:

    public class Test3Polymorpic {
        public static void main(String[] args) {
            useAnimal(new Dog());
            useAnimal(new Cat());
        }
    
        public static void useAnimal(Animal a){  
            a.eat();
        }
        
    }
    
    abstract class Animal {
        public abstract void eat();
    }
    
    class Dog extends Animal {
        public void eat() {
            System.out.println("狗吃肉");
        }
    }
    
    class Cat extends Animal {
        public void eat() {
            System.out.println("猫吃鱼");
        }
    }
    
    
  • 多态的弊端

    不能使用子类特有的成员

自由练习-10分钟
5.多态中的转型 【重点】(视频15) (6‘’)
  • 多态中的向上转型

    父类引用指向子类对象其实就是向上转型。例如:
    Animal a = new Dog();

    public class Test1Polymorphic {
    	
        //同一个对象 new Cat(); 可以使用不同类型的变量 作为返回值
        public static void main(String[] args) {
            Cat c = new Cat();
            Animal a = new Cat();  //向上转型
            a.eat();
        }
    }
    
    class Animal {
        public void eat(){
            System.out.println("动物吃饭");
        }
    }
    
    class Cat extends Animal {
        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
    }
    
  • 多态中的向下转型

    将父类型的引用转换成具体的子类对象。转换格式:
    子类 对象名 = (子类)父类引用;

    public class Test3Polymorpic {
        public static void main(String[] args) {
            useAnimal(new Dog());
            useAnimal(new Cat());
        }
    
        public static void useAnimal(Animal a){
            Dog dog = (Dog) a;  //向下转型  
            dog.watchHome();
        }
    
    }
    
    abstract class Animal {
        public abstract void eat();
    }
    
    class Dog extends Animal {
        public void eat() {
            System.out.println("狗吃肉");
        }
    
        public void watchHome(){
            System.out.println("看家");
        }
    }
    
    class Cat extends Animal {
        public void eat() {
            System.out.println("猫吃鱼");
        }
    }
    
6.多态中转型存在的风险和解决方案 【重点】(视频16) (6‘’)
  • 多态中转型存在的风险

    代码运行的过程中可能会出现 ClassCastException 类型转换异常

  • 多态中转型风险的解决方案

    如何避免强转可能会出现的问题
    关键字 instanceof
    使用格式:
    变量名 instanceof 类型
    通俗的理解:判断关键字左边的变量,是否是右边的类型,返回boolean类型结果

    public class Test3Polymorpic {
        public static void main(String[] args) {
            useAnimal(new Dog());
            useAnimal(new Cat());
        }
    
        public static void useAnimal(Animal a){    		
             //存在风险   ClassCastException  类型转换异常
     	     //Dog dog = (Dog) a;
             //dog.watchHome();
           
            //解决方案  判断a变量记录的类型, 是否是Dog
            if(a instanceof Dog){
                Dog dog = (Dog) a;
                dog.watchHome();
            }
    
        }
    }
    
    abstract class Animal {
        public abstract void eat();
    }
    
    class Dog extends Animal {
        public void eat() {
            System.out.println("狗吃肉");
        }
    
        public void watchHome(){
            System.out.println("看家");
        }
    }
    
    class Cat extends Animal {
        public void eat() {
            System.out.println("猫吃鱼");
        }
    }
    
自由练习-5分钟
7.黑马信息管理系统-多态改进 【】(视频17) (6‘’)
  • 工厂类,以多态的形式返回对象

    public class StudentDaoFactory {
        public static BaseStudentDao getStudentDao(){
            return new OtherStudentDao();
        }
    }
    
  • StudentService类

    public class StudentService {
        // 通过学生库管工厂类, 获取库管对象
    	private BaseStudentDao studentDao = StudentDaoFactory.getStudentDao();
    }
    
  • 代码图

在这里插入图片描述

Transformer实战——Transformer自编码模型 自编码模型依赖于原始 Transformer 编码器,并且在解决分类问题时非常高效。除了 BERT 外,还有许多流行的自编码模型,在本节中,我们将一些除 BERT 外的自编码模型,这些模型的目标是通过优化预训练过程、增加层数或头数、改善数据质量、设计更好的目标函数等,来在下游任务上取得更好的表现。这些改进大致可以分为两个方面,更好的架构设计选择和预训练控制。 阅读详情

相关推荐

Android AudioFlinger(一)——初识AndroidAudio Flinger

AudioFlinger 是 Android 系统中的音频中间层(audio HAL, Audio Hardware Abstraction Layer)的一部分,负责管理音频的混音、播放和音量控制等功能。它充当 Android 应用程序和音频硬件之间的桥梁。

hirezy 1673

DAY06_面向对象高级(3)&接口&多态

接口,多态,管理系统改用为集合存储,使用接口和多态优化管理系统代码

m0_57075290的博客 130

802.1AS时间同步机制深度解析:从Sync报文到多域冗余设计

本文深度解析了802.1AS时间同步机制,从Sync与Follow_Up报文的核心交互原理入手,详细阐述了其如何通过精确的时钟频率比测量、链路延迟计算和驻留时间补偿来实现微秒乃至纳秒级同步。文章进一步探讨了802.1AS-2020版本引入的多时钟域冗余设计,为构建高可靠的车载TSN网络提供了关键见解和实战配置指南。

pytorch8learner的博客 465

java 3 接口与多态&输入输出流

接口 中的所有方法都是方法 抽象 使用接口实现多继承 类型的装换 数据成员就变成了static 和 final food 和 snow 都是可以吃的 可以同时实现多个接口 接口与接口之间也可以有继承关系 类型转换 向上转换 显式转换 显示转换 超类的引用不能访问子类的方法 方法的查找 实例方法查找 从创建对象的时候向上查找 这里和C++不太一样 ...

weixin_30439031的博客 160

从摄像头选型到PCB布线:搞懂MIPI CSI带宽计算,避免你的嵌入式项目翻车

本文详细解析了MIPI CSI带宽计算在嵌入式项目中的关键作用,从摄像头选型到PCB布线提供全流程指导。通过实际案例和计算公式,帮助工程师准确计算带宽需求,避免图像丢帧和系统崩溃问题,同时优化PCB设计确保信号完整性。

weixin_30533109的博客 377

RISC-V嵌入式开发实战:手把手教你读懂并修改CH32V103的链接脚本(.ld)

本文深入解析RISC-V嵌入式开发中CH32V103链接脚本(.ld)的编写与优化技巧。从内存布局、段分配到实战调试,详细讲解如何解决程序跑飞、变量异常等典型问题,特别针对RISC-V架构的gp寄存器优化、中断向量表处理等特性提供专业指导,帮助开发者充分利用64KB Flash和20KB RAM资源。

weixin_33704234的博客 177

Java 接口&多态习题答案

基础题目 第一题:概念辨析 什么是接口,如何定义接口? 接口,是Java语言中一种引用类型,是方法的集合。 使用interface关键定义接口,其中可以定义抽象方法,默认方法,私有方法,静态方法等方法。 什么叫做多态,条件是什么? 一类事物的行为,具有多种表现形式。 条件: 继承或者实现【二选一】 方法的重写。 父类引用指向子类对象。 使用多态特性,带来了什么样的好处? 增强...

kai46385076的专栏 6455

gitlab远程子仓库配置SSH - 保姆级教程

在网上搜索了一些方法,但是不够详细,走了好多弯路,所以记录下配置SSH的详细过程吧。

是菠萝的博客 1万+

接口&多态

接口,是Java语言中一种引用类型,是方法的集合,如果说类的内部封装了成员变量、构造方法和成员方法,那么接口的内部主要就是封装了方法(功能),包含抽象方法 (JDK7及以前) , 默认方法和静态方法(JDK8)私有方法(JDK9)。接口就是一种公共的规范标准,只要符合规范标准,大家都可以通用。Java中的接口更多的体现在对行为的抽象!接口用关键字interface修饰public interface 接口名 {}​@Override​@Override​@Override。

Yuyang_Leo的博客 920

python基础:工作会用到的95%的基础python代码都在这了(万字详解!)

本文是一份Python编程语言的快速参考备忘单,涵盖了Python基础语法和常用数据类型。主要内容包括:Python入门指南(打印、变量声明)、内置数据类型(字符串、数值、列表、元组、集合、字典等)、控制结构(判断、循环)、函数定义、文件处理操作以及字符串操作方法(切片、循环遍历等)。这个备忘单特别适合初学者快速查阅Python基础语法,同时也提供了数据类型转换、f-string格式化字符串等实用技巧。通过简洁的代码示例展示了Python的基本语法规则和典型用法。

数据知道的博客 8166

出现Command ‘vim‘ is available in the following places,vim: command not found等解决方法

内置命令无法识别,说明系统变量有误,导致无法识别,既然系统变量有误,将其注释或者更改为正确的即可,但是现在打不开,又怎么注释掉。替换vim来打开编辑,打开之前错误的全局变量文件,发现变量有误,要么注释要么改为。系统变量有全局变量(通过命令行printenv或者echo)和局部变量。对应通过vim修改错误的变量文件,不然source也无法让配置文件生效。本身vim是系统内置的命令,连vim都出现问题。修改为正确的即可,之后还需要重启服务器,使用。之后即可成功,通过即可查看命令是否有写入。...

码农研究僧的博客 5884

day08 接口&多态

接口就是一种公共的规范标准,只要符合规范标准,大家都可以通用。Java中的接口更多的体现在对行为的抽象!应用场景:为了功能扩展,提高程序的可扩展性。java不支持,多重继承,假设现在有一个需求,就需要继承多个类 的特点?变通方式,接口。坦克:陆地跑 突突船:游泳,滑行;接口用关键字interface修饰public interface 接口名 {}默认方法:使用 default 修饰,不可省略,供子类调用或者子类重写。public default 返回值类型 方法的名称(参数列表){

wsskl的博客 1747

北斗导航 | ILS(仪表着陆系统)、MLS(微波着陆系统)和GBAS(地基增强系统)的性能对比

最 早 的 GBAS 系 统 是 **局 域 增 强 系 统(LAAS)**,它是 1990 年由美国 Honeywell 公司 和 NASA 共 同 完 成 的 差 分 GPS(DGPS)演 变 而 来 的。1998 年,LAAS 被 ICAO 采 纳为 GBAS。2009 年 9 月 3 日 Honeywell 公 司 的GBAS 系统通过了 **CAT-I 精密进近着陆系统**的设计认证 ,而 **CAT-II 和 CAT-III 系统的研发和验证工作也正在有序的进行中**

尘世冰封的专栏 3994

【Java学习】多态&抽象类&接口

一般情况下,父类中的方法被子类们重写,而且子类各自的实现都不一样,那么父类中不停被重写的方法只有方法声明还有意义,方法主体便可以省去,父类只需提供一个没有方法体的定义即可,具体功能交给子类自行定义。没有方法体的方法称为抽象方法。Java语法规定,包含抽象方法的类就是抽象类。抽象方法: 没有方法体的方法。抽象类:包含抽象方法的类。abstract在抽象类中可以用抽象方法,也可以有普通方法,构造方法,成员变量等。而接口是更加彻底的抽象,JDK7之前,包括JDK7,接口中全部是抽象方法。

weixin_69134024的博客 1013

jre9下载 jdk9

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

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

笔记12-多态&抽象类&接口

1.多态 1.1多态的概述(记忆) 什么是多态 ​ 同一个对象,在不同时刻表现出来的不同形态 多态的前提 要有继承或实现关系 要有方法的重写 要有父类引用指向子类对象 1.2多态中的成员访问特点(记忆) 成员访问特点 成员变量 ​ 编译看父类,运行看父类 成员方法 ​ 编译看父类,运行看子类 代码演示 动物类 public class Animal { public int age = 40; public void eat() {

terence的博客 5万+

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

抽象类&接口&多态(重载 | 重写)

动物不应该定义为具体的东西,而且动物中的吃,睡等也不应该是具体的。我们把一个不是具体的功能称为抽象的功能,而一个类中如果有抽象的功能,该类必须是抽象类。

小方的博客 988

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的&ldquo;数理统计&rdquo;课程中有一章专门讲授&ldquo;贝叶斯方法和统计决策理论&rdquo;,近十年来也给中国科学技术大学概率统计专业研究生开设过几次&ldquo;贝叶斯分析&rdquo;课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了&ldquo;贝叶斯统计推断&rdquo;和&ldquo;贝叶斯统计决策&rdquo;的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标&ldquo;*&rdquo;号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

继承&抽象&多态&接口

面向对象思想:不同对象之间相互访问--》 new 对象().方法思想就是懒人思想,找人帮忙做面向对象三大特征:封装、继承、多态。

2301_77165049的博客 947

java接口&多态

JAVAOOP 一、课程目标 1. 【理解】什么是接口 2. 【掌握】接口的定义格式 3. 【掌握】接口的使用 4. 【理解】接口的成员特点 5. 【理解】类和接口 抽象类和接口之间的关系 6. 【掌握】单继承多实现 7. 【理解】接口之间的多继承 8. 【掌握】接口的案例 9. 【理解】什么是动态 10. 【理解】使用多态的前提 11. 【掌握】多态的格式 12. 【理解】多态中的成员访问特点 13. 【理解】多态中的好处和弊端 14. 【理解】多态中的转型 15. 【理解】转型的异常 16. 【掌握

qq_53347907的博客 420

【c#】接口、继承、多态、接口的多态

1.接口     定义:接口是把公共实例(非静态)方法和属性组合起来,以封装特定功能的集合 一旦定义了接口,就可以在类中实现它,类就可以支持接口的属性和方法一个类可以支持多个接口,多个类可以支持相同的接口发布接口后,最好不要修改它 如果修改了接口,该接口的使用者就不能正确使用该接口; 所以我们应该创建一个新的接口,使其扩展就的接口,可能还包含一个版本号,如X2

学习ing......... 1560

多态&抽象类&接口

多态&抽象类&接口

m0_71174751的博客 815

多态&抽象&接口

多态: 多态的概念: 多态:事物的多种状态 对象的多态性:同一个对象,可能具有不同的名称,同一个对象,有不同类型的引用指向它,本质:同一个物体有不同的名称和描述。 类型的多态性:同一个类型,可能具有不同的子类实现。 多态的前提: 1.要有父子类的继承(实现)关系。 2.有方法的重写。 3.父类的引用指向子类的对象。 代码示例: 1 class Demo01_多态概述 { ...

weixin_30716725的博客 80
上一篇: 2继承&抽象类 代码块
下一篇: 4内部类&Lambda 匿名内部类和Lambda表达式的区别
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、付费专栏及课程。

余额充值