精华内容
下载资源
问答
  • java名词解释及简答题
    千次阅读
    2020-04-22 13:12:13

    一、 名词解释

    父类
    被直接或间接继承的类。
    子类
    由已存在的类派生出的新类。
    方法覆盖
    若子类中的方法与父类中的某一方法具有相同的方法名、返回类型和参数表,则新方法将覆盖原有的方法。
    object类
    Java程序中所有类的直接或间接父类,类库中的所有类的父类,处在类层次的最高点。
    自动装箱
    自动将基本数据类型用它对应的引用类型包装起来,使它可以具有对象的特质。
    自动拆箱
    自动将包装类转换成基本数据类型。
    类的访问权限
    Java中提供了三个关键字在类的内部设置边界,控制类的访问权限。
    public:表示其后的元素对任何人都可以使用。
    private:表示其后的元素除了类型的创建者和内部的方法之外任何人都不能访问。
    protected:与private相当,差别在于继承的类可以访问protected修饰的元素,同包中的其他类元素也可以访问。
    默认的访问权限:在不指定任何关键字的情况下,这种权限将发挥作用,它是一种包的访问权限,即在当前包中的任何元素都可以访问。
    抽象类
    一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。
    接口
    接口在JAVA编程语言中是一个抽象类型,是抽象方法的集合,接口通常以interface来声明。一个类通过继承接口的方式,从而来继承接口的抽象方法。
    单重继承
    一个类只可以继承自一个父类。
    多重继承
    一个类可以同时继承多个父类。
    对象转换
    Java 语言允许某个类型的引用变量引用子类的实例,而且可以对这个引用变量进行类型转换。
    对象的自动转换
    把引用类型转换为子类类型,可以自动转换。
    对象的强制转换
    把引用类型转换为父类类型,必须进行强制类型转换。
    静态多态
    程序在编译时,系统就能决定调用哪个函数。
    动态多态
    在运行中才能动态确定操作指针所指的对象,主要通过虚函数和重写来实现。
    方法绑定
    指将一个方法调用同一个方法主体连接到一起。
    前期绑定
    程序运行之前绑定。
    后期绑定
    也叫做“动态绑定”或“运行期绑定”,基于对象的类别,在程序运行时执行绑定。

    二、简答题

    1、抽象类的特点和存在的主要意义是什么?
    特点:代表抽象概念,没有具体实例对象
    类前需要加修饰符abstract
    可包含常规类能够包含的任何东西,例如构造方法,非抽象方法
    可包含抽象方法
    一个非抽象类继承抽象类,必须将抽象类中的抽象方法覆盖、实现、重写
    意义:
    让其他类来继承它的抽象化的特征
    包含子类共享的公共行为、属性
    不能创建对象,保证代码的安全性,有利于代码的维护和重用
    2、终结类的特点和存在的主要意义是什么?
    特点:终结类不能被继承(不能有派生类)
    是被final修饰符修饰的类
    意义:
    1)防止子类对父类关键方法的错误重写,增加了代码的安全性
    2)提高运行效率
    3、什么是泛型,引入泛型的主要目的是什么?
    泛型本质是参数化类型,即所操作的数据类型被指定为一个参数。
    使Java语言变得更加简单、安全,在使用泛型的情况下,编译器会检查是否安全,并且所有的类型转换都是自动和隐式的,可以提高代码的重用率
    4、接口的特点和存在的主要意义是什么?
    特点:
    1)接口允许在不相干的对象之间定义共同行为
    2)接口的数据成员一定要赋初值,且此值将不能再更改,允许省略final关键字
    3)接口中的方法必须是“抽象方法”,不能有方法体,允许省略public及abstract关键字
    4)接口不能用new运算符直接产生对象,必须利用其特性设计新的类,再用新的类来创建对象
    5)必须实现接口中的所有方法,来自接口的方法必须声明public
    意义:
    1)是面向对象的一个重要机制
    2)实现java中的多继承,免除C++中的多继承的复杂性
    3)建立类和类之间的“协议”:把类根据其实现的功能来分别代表,而不必顾虑它所在的类继承层次,这样可以最大限度地利用动态绑定,隐藏实现细节
    4)实现不同类之间的常量共享
    5、java中为什么要引入多态机制?
    1)所有的对象都可被塑型为相同的类型,响应相同的消息
    2)使代码变得简单且容易理解
    3)使程序具有很好的“扩展性”

    更多相关内容
  • java程序设计名词解释

    2021-03-08 08:19:40
    3、多态:一个对象变量可以指向多种实际类型的现象。4、接口:用来实现类似多重继承功能的一种结构,它在语法上与类相似,它也有属性和方法,接口间也可以形成继承关系,但继承和类有很大的差别,它的属性都是常量,...

    1、封装:将对象的数据与操作数据的方法结合起来,通过方法将对象的数据和实现细节保护起来,称为封装。

    2、继承:一种由已有类创建新类的机制。

    3、多态:一个对象变量可以指向多种实际类型的现象。

    4、接口:用来实现类似多重继承功能的一种结构,它在语法上与类相似,它也有属性和方法,接口间也可以形成继承关系,但继承和类有很大的差别,它的属性都是常量,方法都是抽象方法,没有方法体。

    5、异常:在程序执行中,任何中断正常程序流程的异常条件就是错误或异常。

    6、构造方法:名字与他所在类的名字相同,并且不返回任何数据类型。

    7、线程生命周期:一个线程从创建、运行到消亡的过程。

    8、final类:不能被继承,即不可能有子类。

    9、内部类:可将一个类定义置入另一个类定义中。

    10、方法的覆盖:如果子类中定义的某个成员方法与父类中的某个方法的名称,返回类型和参量完全相同为覆盖。。

    11、JDBC:是一种用于执行SQL语句的JAVA API,可以为多种关系数据提供统一访问,他由一组用JAVA语言编写的类和接口组成。

    12、抽象类:声明方法的存在而不实现的类。

    13、static块:静态变量或静态方法,不需要实例化就可以被调用的。

    14、斐波那契数列:若一个数列前两项等于一,从第三项起,每一项等于前两项之和。

    15、多线程同步处理:当多个线程想访问一个资源时,在任何给定的时间都只有一个线程可以访问。

    16、匿名同步类:如果只需要内部类的一个对象,那么你不必给该类一个名字,这时候我们称为匿名内部类。

    17、死锁:当一个线程需要一个资源,而另一个线程持有该资源的锁,就会发生死锁

    18、方法的重载:JAVA语言允许用相同的方法名定义类中若干个成员方法,只要每个方法有自己唯一的一组形式参数,这种现象称为方法的重载。

    19、面向对象:在编程过程中采用的封装、继承、多态的编程方法。

    20、脏读数据; 脏读就是指当一个事务正在访问数据,并且对数据进行了修改,而这种修改还没有提交到数据库中,这时,另外一个事务也访问这个数据,然后使用了这个数据。

    21、多线程:在单的程序中可以同时运行多个不同的线程,执行不同的任务。

    22、类:具有相同的特性和行为的集合。

    23、堆栈调用机制:我们可以从线程当前堆栈中了解到调用它的那几个那几个函数分别是谁,呈现出一种堆栈的特征,最后别调用的函数出现在最上方,成为,堆栈调用机制。

    24、对象:对象是在其类模型基础上构造出的,是类的具体的实例。一个类可以生成任意多的对象。

    25、单态模式:Singleton模式主要作用是保证在Java应用程序中,一个类Class只有一个

    实例存在。Singleton模式就为我们提供了这样实现的可能。使用Singleton的好处还在于可以节省内存,因为它限制了实例的个数,有利于Java垃圾回收(garbage collection)。

    26、事件(Event):当用户在界面上执行一个操作(如按下键盘或单击、拖动鼠标)时,都将产生一个事件。可见,事件用来描述不同类型用户操作的对象。Java有很多不同类型的事件类,对应不同类型的用户动作

    27、事件源(Event source):产生事件的组件就是一个事件源。例如,在一个Button上单击鼠标时,将产生一个ActionEvent类型的事件,那么这个Button就是事件源。

    28、事件处理器(Event handle):事件处理器就是一个方法,它接收一个事件对象,对其进行解释,并做出相应的处理。

    29、异常:Java程序中,由于程序员的疏忽或环境的变化,在程序运行时出现的打断正常程序流程的不正常情况。

    30、输入流:Java可以打开一个从某种数据源(如文件、内存等)到程序的一个流,从这个流中读取数据,这就是输入流。它只能从流中读出,不能向流中写入。21、输出流:Java可以打开一个从程序到某种数据宿(如文件、内存等)的一个流,把数据顺序写入这个流以便输出,这就是输出流。它只能向流中写入,不能从流中读出。

    31、重载:在同一个类中,一个方法名被用来定义多个方法,要求参数表必须不同,以此区分不同方法体,但返回类型、修饰符可相同或不相同。它实现了Java的编译时多态。

    32、重写:当子类成员方法与父类成员方法具有相同的名字、参数列表、返回值类型时,子类方法重写了父类方法,在父类中定义的方法就被隐藏。它实现了Java的运行时多态。

    33、构造方法:构造方法是类的一种特殊方法,方法名与类名相同,在类实例化对象时被调用,用于初始化类的成员变量、分配资源或其他辅助工作。

    34、包:包是类和接口的集合,它把同一种类型的类(接口)组织在一起,使得程序功能清楚、结构分明,更重要的是可实现不同程序间类的重用。

    35、JVM:Java虚拟机的缩写,是一个软件系统,可以解释并运行Java字节码。

    36、API:应用程序接口的缩写,Java API是Java平台定义的一套类和接口的程序库。

    37、容器异常:Spring 提供容器功能,容器可以管理对象的生命周期、对象与对象之间的依赖关系,您可以使用一个配置文件(通常是XML),在上面定义好对象的名称、如何产生(Prototype 方式或Singleton 方式)、哪个对象产生之后必须设定成为某个对象的属性等,在启动容器之后,所有的对象都可以直接取用,不用编写任何一行程序代码来产生对象,或是建立对象与对象之间的依赖关系。换个更直白点的说明方式:容器是一个Java 所编写的程序,原先必须自行编写程序以管理对象关系,现在容器都会自动帮您作好。

    展开全文
  • Java基础_静态与多态

    2020-12-26 15:37:27
    Day_10 static关键字与多态 一.static关键字 1.定义:用于修饰成员变量和成员方法。 2.特点: <1>随着类的加载而加载,优先于对象加载。 <2>只加载一次就会一直存在,不再开辟新的空间。 <3>全局...

    Day_10 static关键字与多态

    一.static关键字
    1.定义:用于修饰成员变量和成员方法。
    2.特点:
    <1>随着类的加载而加载,优先于对象加载。
    <2>只加载一次就会一直存在,不再开辟新的空间。
    <3>全局唯一,全局共享。
    <4>可以直接被类名调用。
    <5>静态只能调用静态,非静态可以随意调用。
    <6>static不能和super或者this共用,因为有static的时候可能还没有对象。

    二.入门案例

    public class Static {
    
    	public static void main(String[] args) {
    		
    		/*int i = Student.age;//优先于对象加载,有没有对象都有static。
    		System.out.println(i);*/
    		
    		Student s = new Student();
    		
    		System.out.println(s.name);
    		System.out.println(s.age);
    		
    		s.speak();
    		s.eat();
    
    	}
    
    }
    
    class Student{
    	
    	String name = "Yan Dexuan";
    	static int age = 20;
    	
    	public static void speak() {
    		
    		System.out.println("说话");
    		
    	}
    	
    	public void eat() {
    		
    		System.out.println("吃饭");
    		
    	}
    	
    }
    

    三.静态调用关系

    public class Static_Relationship {
    
    	public static void main(String[] args) {
    		
    		Teacher t = new Teacher();
    		
    		t.speak();
    
    	}
    
    }
    
    class Teacher{
    	
    	static int age = 30;
    	String name = "Yan Dexuan";
    	
    	//非静态测试,非静态能够调用静态方法。
    	public void speak() {
    		
    		System.out.println(age);
    		System.out.println(name);
    		qiao();
    	}
    	
    	//静态测试,静态能调用静态。
    	public static void qiao() {
    		
    		System.out.println(age);
    		//System.out.println(name);静态无法调用非静态。
    		//speak();
    	}
    	
    }
    

    四.静态代码块
    1.随着类的加载而加载,并且只被加载一次,一般情况下用于项目的初始化。static{…}。
    2.静态代码块:在类加载时就加载,并且只被加载一次,一般用于项目的初始化。
    3.构造代码块:在调用构造方法前会自动调用,每次创建对象都会被调用。
    4.静态代码块:static{…},位于类里方法外。
    5.执行顺序:静态-构造代码块-构造-局部代码块。

    五.代码执行顺序

    public class Static_Block {
    
    	public static void main(String[] args) {
    		
    		Car c = new Car();
    		c.show();
    		
    	}
    
    }
    
    class Car{
    	
    	//1.静态代码块。
    	static{
    		System.out.println("静态代码块");
    	}
    	
    	//2.构造代码块。
    	{
    		System.out.println("构造代码块1");
    	}
    	
    	//3.构造方法。
    	public Car() {
    		System.out.println("构造方法");
    	}
    	
    	//4.局部代码块。
    	public void show() {
    		
    		{
    		System.out.println("构造代码块2");
    		}
    		
    		System.out.println("局部代码块1");
    		System.out.println("局部代码块2");
    		
    	}
    	
    }
    

    六.final关键字
    1.定义:final用于修饰类,方法以及成员变量。
    2.特点:
    <1>被final修饰的类,不能被继承。
    <2>被final修饰的方法,不能被重写。
    <3>被final修饰的变量是个常量,值不能被更改。
    <4>常量的定义形式:final 数据类型 常量名 = 值。

    七.final入门案例

    public class Final {
    
    	public static void main(String[] args) {
    		
    		Son s = new Son();
    		
    		s.speak();
    		
    		System.out.println(s.name);
    		
    		s.test();
    		
    
    	}
    
    }
    
    class Father{
    	
    	final String name = "Yan Dexuan";
    	
    	public final void speak() {
    		
    	   System.out.println("说话");
    		
    	}
    	
    }
    
    class Son extends Father{
    	
    	//被final的方法,不能被重写。
    	/*public void speak() {
    		
    		System.out.println("说什么");
    		
    	}*/
    	
    	public void test() {
    		
    		//super.name = "Yan";
    		//被final的变量,不能被重新赋值。
    		System.out.println(super.name);
    		
    	}
    	
    }
    

    八.多态
    1.定义:多态指同一个实体同时具有多种形式,他是面向对象程序设计的一个重要特征。主要是指同一个对象,在不同的时刻,代表的对象不一样,指的是对象的多种形态。

    2.优点:
    <1>可以吧不同的子类对象都当做父类来看,可以屏蔽不同子类对象之间的差异,写出通用的的代码,作出通用的变成,统一调用标准。例如,水在不同时刻可以有多种形态,包括水蒸气,冰以及水。Java体现多态,比如,狗有两种形态,狗和小动物。
    <2>多态可以让我们不用关心某个对象到底是什么具体类型,就可以使用该对象的某些方法。
    <3>提高了程序的拓展性和可维护性。

    3.特点:
    <1>多态的前提是继承。
    <2>要有方法的重写。
    <3>父类引用指向子类对象,例如:Animal a =new Dog();从小到大,向上转型。
    <4>多态种,编译看左边,运行看右边。
    <5>成员变量:使用的是父类的。
    <6>成员方法:使用的是子类的。
    <7>静态成员:随着对象而存在,谁调用就返回谁。

    九.多态入门案例

    public class Polymorphism {
    
    	public static void main(String[] args) {
    		
    		Animal a = new Dog();//父类引用指向子类对象,把右边的小的给左边的大的。
    		a.eat();//只能使用父类的功能,这样就统一了调用的标准。
    
    	}
    
    }
    
    class Animal{
    	
    	public void eat() {
    		
    		System.out.println("动物吃饭");
    		
    	}
    	
    }
    
    class Dog extends Animal{
    	
    	public void kanjia() {
    		
    		System.out.println("看家");
    		
    	}
    	
    	public void eat() {
    		
    		System.out.println("吃骨头");//发生重写,所以父类的方法被覆盖了。
    		
    	}
    	
    }
    

    十.多态的使用

    public class Polymorphism_Use {
    
    	public static void main(String[] args) {
    		
    		Mother m = new Son3();
    		
    		System.out.println(m.number);//成员变量,使用的是父类的。
    		
    		m.study();//成员方法,使用的是子类的。
    		
    		System.out.println(Son3.count);//静态成员,谁调用就是谁的。
    		m.sleep();
    		
    		System.out.println();
    
    	}
    
    }
    
    class Mother{
    	
    	int number = 10;
    	
    	static int count = 100;
    	
    	public void study() {
    		
    		System.out.println("妈妈学习");
    		
    	}
    	
    	public static void sleep() {
    		
    		System.out.println("儿子睡觉");
    		
    	}
    	
    }
    
    class Son3 extends Mother{
    	
    	int number = 20;
    	
    	static int count = 200;
    	
    	public void study() {
    		
    		System.out.println("儿子学习");
    		
    	}
    	
    	public static void sleep() {
    
    		System.out.println("儿子睡觉");
    	}
    	
    }
    

    十一.执行顺序:静态代码块—构造代码块—构造函数

    public class Comparation {
    
    	public static void main(String[] args) {
    		
    		Block b = new Block();
    		
    		System.out.println();
    		
    		Block b2 = new Block();//静态代码只会被执行一次,就是在类第一次初始化时。
    		
    
    	}
    
    }
    
    class Block{
    	
    	{
    		System.out.println("构造代码块1");
    	}
    	
    	static {
    		System.out.println("静态代码块1");
    	}
    	
    	public Block(){
    		
    		{
    			System.out.println("局部代码块1");
    		}
    		
    	}
    	
    	{
    		System.out.println("构造代码块2");
    	}
    	
    	static {
    		System.out.println("静态代码块2");
    	}
    	
    }
    

    十二.静态变量和实例变量的区别
    1.在语法定义上的区别:静态变量之前要加static关键字,而实例变量不用加。

    2.在程序运行时的区别:实例变量属于某个对象的属性,必须创建了实例对象,其中的实例变量才会被分配空间,才能使用这个实例变量。而静态变量不属于某个实例对象,而是属于类,所以也称为类变量,只要程序加载了类的字节码,不用创建任何实例对象,静态变量就会被分配空间,静态变量就可以被使用了。总之,实例变量必须创建对象后才可以通过这个对象来使用,静态变量则可以直接使用类名来引用。

    展开全文
  • Java基础之多态的详细解释

    千次阅读 2016-10-26 22:13:09
    一、面向对象最核心的机制——动态绑定,也叫多态   1.1.通过下面的例子理解动态绑定,即多态 1 package javastudy.summary; 2 3 class Animal { 4 /** 5 * 声明一个私有的成员变量nam

    http://www.cnblogs.com/xdp-gacl/p/3644035.html

    一、面向对象最核心的机制——动态绑定,也叫多态

      

    1.1.通过下面的例子理解动态绑定,即多态

    复制代码
      1 package javastudy.summary;
      2 
      3 class Animal {
      4     /**
      5      * 声明一个私有的成员变量name。
      6      */
      7     private String name;
      8 
      9     /**
     10      * 在Animal类自定义的构造方法
     11      * @param name
     12      */
     13     Animal(String name) {
     14         this.name = name;
     15     }
     16 
     17     /**
     18      * 在Animal类里面自定义一个方法enjoy
     19      */
     20     public void enjoy() {
     21         System.out.println("动物的叫声……");
     22     }
     23 }
     24 
     25 /**
     26  * 子类Cat从父类Animal继承下来,Cat类拥有了Animal类所有的属性和方法。
     27  * @author gacl
     28  *
     29  */
     30 class Cat extends Animal {
     31     /**
     32      * 在子类Cat里面定义自己的私有成员变量
     33      */
     34     private String eyesColor;
     35 
     36     /**
     37      * 在子类Cat里面定义Cat类的构造方法
     38      * @param n
     39      * @param c
     40      */
     41     Cat(String n, String c) {
     42         /**
     43          * 在构造方法的实现里面首先使用super调用父类Animal的构造方法Animal(String name)。
     44          * 把子类对象里面的父类对象先造出来。
     45          */
     46         super(n);
     47         eyesColor = c;
     48     }
     49 
     50     /**
     51      * 子类Cat对从父类Animal继承下来的enjoy方法不满意,在这里重写了enjoy方法。
     52      */
     53     public void enjoy() {
     54         System.out.println("我养的猫高兴地叫了一声……");
     55     }
     56 }
     57 
     58 /**
     59  * 子类Dog从父类Animal继承下来,Dog类拥有了Animal类所有的属性和方法。
     60  * @author gacl
     61  *
     62  */
     63 class Dog extends Animal {
     64     /**
     65      * 在子类Dog里面定义自己的私有成员变量
     66      */
     67     private String furColor;
     68 
     69     /**
     70      * 在子类Dog里面定义Dog类的构造方法
     71      * @param n
     72      * @param c
     73      */
     74     Dog(String n, String c) {
     75         /**
     76          * 在构造方法的实现里面首先使用super调用父类Animal的构造方法Animal(String name)。
     77          * 把子类对象里面的父类对象先造出来。
     78          */
     79         super(n);
     80         furColor = c;
     81     }
     82 
     83     /**
     84      * 子类Dog对从父类Animal继承下来的enjoy方法不满意,在这里重写了enjoy方法。
     85      */
     86     public void enjoy() {
     87         System.out.println("我养的狗高兴地叫了一声……");
     88     }
     89 }
     90 
     91 /**
     92  * 子类Bird从父类Animal继承下来,Bird类拥有Animal类所有的属性和方法
     93  * @author gacl
     94  *
     95  */
     96 class Bird extends Animal {
     97     /**
     98      * 在子类Bird里面定义Bird类的构造方法
     99      */
    100     Bird() {
    101         /**
    102          * 在构造方法的实现里面首先使用super调用父类Animal的构造方法Animal(String name)。
    103          * 把子类对象里面的父类对象先造出来。
    104          */
    105         super("bird");
    106     }
    107 
    108     /**
    109      * 子类Bird对从父类Animal继承下来的enjoy方法不满意,在这里重写了enjoy方法。
    110      */
    111     public void enjoy() {
    112         System.out.println("我养的鸟高兴地叫了一声……");
    113     }
    114 }
    115 
    116 /**
    117  * 定义一个类Lady(女士)
    118  * @author gacl
    119  *
    120  */
    121 class Lady {
    122     /**
    123      * 定义Lady类的私有成员变量name和pet
    124      */
    125     private String name;
    126     private Animal pet;
    127 
    128     /**
    129      * 在Lady类里面定义自己的构造方法Lady(),
    130      * 这个构造方法有两个参数,分别为String类型的name和Animal类型的pet,
    131      * 这里的第二个参数设置成Animal类型可以给我们的程序带来最大的灵活性,
    132      * 因为作为养宠物来说,可以养猫,养狗,养鸟,只要是你喜欢的都可以养,
    133      * 因此把它设置为父类对象的引用最为灵活。
    134      * 因为这个Animal类型的参数是父类对象的引用类型,因此当我们传参数的时候,
    135      * 可以把这个父类的子类对象传过去,即传Dog、Cat和Bird等都可以。
    136      * @param name
    137      * @param pet
    138      */
    139     Lady(String name, Animal pet) {
    140         this.name = name;
    141         this.pet = pet;
    142     }
    143 
    144     /**
    145      * 在Lady类里面自定义一个方法myPetEnjoy()
    146      * 方法体内是让Lady对象养的宠物自己调用自己的enjoy()方法发出自己的叫声。
    147      */
    148     public void myPetEnjoy() {
    149         pet.enjoy();
    150     }
    151 }
    152 
    153 public class TestPolymoph {
    154     public static void main(String args[]) {
    155         /**
    156          * 在堆内存里面new了一只蓝猫对象出来,这个蓝猫对象里面包含有一个父类对象Animal。
    157          */
    158         Cat c = new Cat("Catname", "blue");
    159         /**
    160          * 在堆内存里面new了一只黑狗对象出来,这个黑狗对象里面包含有一个父类对象Animal。
    161          */
    162         Dog d = new Dog("Dogname", "black");
    163         /**
    164          * 在堆内存里面new了一只小鸟对象出来,这个小鸟对象里面包含有一个父类对象Animal。
    165          */
    166         Bird b = new Bird();
    167 
    168         /**
    169          * 在堆内存里面new出来3个小姑娘,名字分别是l1,l2,l3。
    170          * l1养了一只宠物是c(Cat),l2养了一只宠物是d(Dog),l3养了一只宠物是b(Bird)。
    171          * 注意:调用Lady类的构造方法时,传递过来的c,d,b是当成Animal来传递的,
    172          * 因此使用c,d,b这三个引用对象只能访问父类Animal里面的enjoy()方法。
    173          */
    174         Lady l1 = new Lady("l1", c);
    175         Lady l2 = new Lady("l2", d);
    176         Lady l3 = new Lady("l3", b);
    177         /**
    178          * 这三个小姑娘都调用myPetEnjoy()方法使自己养的宠物高兴地叫起来。
    179          */
    180         l1.myPetEnjoy();
    181         l2.myPetEnjoy();
    182         l3.myPetEnjoy();
    183     }
    184 }
    复制代码

    运行结果:

      

    1.2.画内存图理解动态绑定(多态)

      首先从main方法的第一句话开始分析:

        Cat c = new Cat("Catname","blue");

      程序执行到这里,栈空间里有一个变量cc里面装着一系列的值,通过这些值可以找到位于堆内存里面new出来的Cat对象。因此cCat对象的一个引用,通过c可以看到这个Cat对象的全部。c指向new出来的Cat对象。在new这个Cat对象的时候,调用了Cat对象的构造方法Cat(String n,String c),定义如下:

        Cat(String n,String c){

          super(n);

          eyesColor=c;

        }

      因此在构造子类对象时首先使用父类对象的引用super调用父类的构造方法Animal(String name),定义如下:

        Animal(String name){

          this.name=name;

        }

      因此会把传过来的字符串“Catname”传递给父类对象的name属性。当Cat(String n,String c)构造方法调用结束后,真真正正在堆内存里面new出了一只Cat,这只Cat里面包含有父类对象Animal,这个Animal对象有自己的属性namename属性的值为调用父类构造方法时传递过来的字符串Catname。除此之外,这只Cat还有自己的私有成员变量eyesColoreyesColor属性的属性值为调用子类构造方法时传递过来的字符串blue。所以执行完这句话以后,内存中的布局是栈内存里面有一个引用cc指向堆内存里面new出来的一只Cat,而这只Cat对象里面又包含有父类对象AnimalAnimal对象有自己的属性name,属性值为CatnameCat除了拥有从Animal类继承下来的name属性外,还拥有一个自己私有的属性eyesColor,属性值为blue。这就是执行完第一句话以后整个内存布局的情况如下图所示:

      

    接着看这句话:Lady l1 = new Lady(“l1”,c);

      

      程序执行到这里,首先在栈内存里面多了一个引用变量l1,l1里面装着一个值,通过这个值可以找到在堆内存里面new出来的Lady对象。l1就是这个Lady对象的引用,l1指向Lady对象。在创建Lady对象时,调用Lady类的构造方法:Lady(String name,Animal pet),其定义如下:

      Lady(String name,Animal pet){

        this.name=name;

        this.pet=pet;

      }

      这个构造方法有两个参数,分别是String类型的nameAnimal类型的petpet参数是一个父类对象的引用类型,这里把l1c作为实参传递给了构造方法,接着在构造方法里面执行this.name=name,把传递过来的l1由传给Lady对象的name属性,因此Lady对象的name属性值为l1,这里也把前面new出来的那只Cat的引用c传递给了构造方法里面的参数pet,接着在构造方法里面执行this.pet=petpet参数又把c传过来的内容传递给Lady对象的pet属性,因此pet属性的属性值就是可以找到Cat对象的地址,因此Lady对象的pet属性也成为了Cat对象的引用对象了,通过pet里面装着的值是可以找到Cat对象的,因此pet也指向了Cat,但并不是全部指向Catpet指向的只是位于Cat对象内部的Animal对象,这是因为在调用构造方法时,是把c当成一个Animal对象的引用传过来的,把c作为一个Animal对象传递给了pet,所以得到的pet也是一个Animal对象的引用,因此这个pet引用指向的只能是位于Cat对象里面的Animal对象。在我pet引用对象眼里,你Cat对象就是一只普通的Animal,访问你的时候只能访问得到你里面的name属性,而你的eyesColor属性我是访问不到的,我能访问到你的name属性,访问的是位于你内部里面的父对象的name属性,因为我pet引用本身就是一个父类对象的引用,因此我可以访问父类对象的全部属性,而你子类对象Cat自己新增加的成员我pet引用是访问不了的。不过现在我pet引用不去访问你父类对象的成员变量name了,而是去访问你的成员方法enjoy了。首先是使用Lady对象的引用l1去调用Lady对象的myPetEnjoy()方法,myPetEnjoy()方法定义如下:

      public void myPetEnjoy(){

        pet.enjoy();

      }

      然后在myPetEnjoy()方法体里面又使用pet引用对象去调用父类对象里面的enjoy方法。

      方法是放在代码区(code seg)里面的,里面的方法就是一句句代码因此当使用pet引用去访问父类对象的方法时,首先是找到这个父类对象,然后看看它里面的方法到底在哪里存着,找到那个方法再去执行这里头就比较有意思了,code seg里面有很多个enjoy方法,有父类的enjoy()方法,也有子类重写了从父类继续下来的enjoy()方法,那么调用的时候到底调用的是哪一个呢?是根据谁来确定呢?注意:这是根据你实际当中的对象来确定的,你实际当中new出来的是谁,就调用谁的enjoy方法,当你找这个方法的时候,通过pet引用能找得到这个方法,但调用代码区里面的哪一个enjoy方法不是通过引用类型来确定的,如果是通过引用类型pet来确定,那么调用的肯定是Animalenjoy()方法,可是现在是根据实际的类型来确定,我们的程序运行以后才在堆内存里面创建出一只Cat,然后根据你实际当中new出来的类型来判断我到底应该调用哪一个enjoy()方法。如果是根据实际类型,那么调用的就应该是Catenjoy()方法。如果是根据引用类型,那么调用的就应该是Animalenjoy()方法。现在动态绑定这种机制指的是实际当中new的是什么类型,就调用谁的enjoy方法。所以说虽然你是根据我父类里面的enjoy方法来调用,可是实际当中却是你new的是谁调用的就是谁的enjoy()方法。即实际当中调用的却是子类里面重写后的那个enjoy方法。当然,讲一点更深的机制,你实际当中找这个enjoy方法的时候,在父类对象的内部有一个enjoy方法的指针,指针指向代码区里面父类的Animalenjoy方法,只不过当你new这个对象的时候,这个指针随之改变,你new的是什么对象,这个指针就指向这个对象重写后的那个enjoy方法,所以这就叫做动态绑定。只有在动起来的时候,也就是在程序运行期间,new出了这个对象了以后你才能确定到底要调用哪一个方法。我实际当中的地址才会绑定到相应的方法的地址上面,所以叫动态绑定。调这个方法的时候,只要你这个方法重写了,实际当中调哪一个,要看你实际当中new的是哪个对象,这就叫多态,也叫动态绑定。动态绑定带来莫大的好处是使程序的可扩展性达到了最好,我们原来做这个可扩展性的时候,首先都是要在方法里面判断一下这只动物是哪一类里面的动物,通过if (object instanceof class)这样的条件来判断这个new出来的对象到底是属于哪一个类里面的,如果是一只猫,就调用猫的enjoy方法,如果是一条狗,就调用狗的enjoy方法。如果我现在增加了一个Bird类,那么扩展的时候,你又得在方法里面写判断这只鸟属于哪一个类然后才能调用这只鸟的enjoy方法。每增加一个对象,你都要在方法里面增加一段判断这个对象到底属于哪个类里面的代码然后才能执行这个对象相应的方法。即每增加一个新的对象,都要改变方法里面的处理代码,而现在,你不需要再改变方法里面的处理代码了,因为有了动态绑定。你要增加哪一个对象,你实际当中把这个对象new出来就完了,不再用去修改对象的处理方法里面的代码了。也就是当你实际当中要增加别的东西的时候,很简单,你直接加上去就成了,不用去改原来的结构,你要在你们家大楼的旁边盖一个厨房,很简单,直接在旁边一盖就行了,大楼的主要支柱什么的你都不用动,这就可以让可扩展性达到了极致,这就为将来的可扩展打下了基础,也只有动态绑定(多态)这种机制能帮助我们做到这一点——让程序的可扩展性达到极致。因此动态绑定是面向对象的核心,如果没有动态绑定,那么面向对象绝对不可能发展得像现在这么流行,所以动态绑定是面向对象核心中的核心。

      总结动态绑定(多态):动态绑定是指在“执行期间”(而非编译期间)判断所引用的实际对象类型,根据其实际的类型调用其相应的方法。所以实际当中找要调用的方法时是动态的去找的,new的是谁就找谁的方法,这就叫动态绑定。动态绑定帮助我们的程序的可扩展性达到了极致。

    多态的存在有三个必要的条件:

    1. 要有继承(两个类之间存在继承关系,子类继承父类)
    2. 要有重写(在子类里面重写从父类继承下来的方法)
    3. 父类引用指向子类对象

      这三个条件一旦满足,当你调用父类里面被重写的方法的时候,实际当中new的是哪个子类对象,就调用子类对象的方法(这个方法是从父类继承下来后重写后的方法)。

      面向对象比较强调类和类之间,对象和对象之间的一种组织关系,如果能把这种组织关系组织得比较好的话,你的程序想扩展性比较好,比较健壮,维护性比较好这些都可以达到,关键看你的设计到底好还是不好。

    展开全文
  • 当我看进去以后,我才发现:它就是一些java基础上的朴实无华的应用,包括ioc,包括许许多多这样的名词,都是万变不离其宗而已。 2.为什么用aop  1就是为了方便,看一个国外很有名的大师说,编程的人都...
  • 面向对象名词解释

    千次阅读 2019-11-10 19:56:57
    面向对象的特点有:抽象、封装、继承、多态。 抽象:抽象就是将现实生活中的事物,忽略与当前目标无关的方面,抽取出当前有用的属性和方法,使用类来表示。 封装:①封装就是使用private隐藏类的内部属性,使用set...
  • C++名词解释

    千次阅读 2019-08-02 10:48:15
    C++的三大特性为:继承,多态,封装 继承指的是通过继承已存在的类所拥有的成员而生成新的类。 封装指的是在类所拥有的成员中,隐藏掉那些没有必要展现给该类调用者的成员。 多态指的是针对同一种消息,不同的...
  • Python名词解释

    千次阅读 2019-09-18 20:53:55
    ”)由于强调接口而非特定类型,设计良好的代码可通过允许多态替代来提升灵活性。鸭子类型避免使用 type() 或 isinstance() 检测。(但要注意鸭子类型可以使用 抽象基类 作为补充。) 而往往会采用 hasattr() 检测或是...
  • java基础--名词解释汇总

    千次阅读 多人点赞 2017-06-01 16:05:46
    下面为大家汇总了Java名词解释大全,希望对同学们学习java有帮助!  面向对象:面向对象程序设计(Object-Oriented Programming)是一种起源于六十年代,发展已经将近三十年的程序设计思想。其自身理论已十分完善...
  • 静态多态 动态多态

    千次阅读 2018-04-15 19:00:38
    静态多态 1. 何为静态多态? 又称编译期多态,即在系统编译期间就可以确定程序将要执行哪个函数。例如:函数重载,通过类成员运算符指定的运算。 2. 示例代码 函数重载示例: class A { public: A() {} ...
  • 【遗传学名词解释

    2021-11-17 16:03:08
    通常对机体有害 多态(polymorphism):某一基因座位中的等位基因变异超过1%,则该座位即为多态的 动态突变( Dynamic mutation )是指基因组串联重复的核苷酸序列随世代传递而拷贝数逐代扩增累加的突变方式,是导致...
  • 名词解释 chromosome disease染色体病——染色体数目或结构异常引起的疾病称为染色体病。 dynamic mutation动态突变——又称不稳定三核苷酸重复序列突变。突变是由基因组中脱氧三核苷酸串联重复拷贝数增加,拷贝数...
  • 名词解释类:一个类即是对一类拥有相同属性的对象的抽象、蓝图、原型、模板。在类中定义了这些对象的都具备的属性(variables(data))、共同的方法属性:人类包含很多特征,把这些特征用程序来描述的话,叫做属性,...
  • C++---静态多态与动态多态

    万次阅读 多人点赞 2018-08-02 18:32:37
    多态 多态按字面的意思就是多种形态,相同的方法调用,但是有不同的实现方式。多态性可以简单地概括为“一个接口,多种方法”。 C++有两种多态形式: 静态多态 动态多态 静态多态 静态多态:也称为编译期间...
  • C++(面向对象的程序设计)考前必背的名词解释和简答题1. 封装 封装是将数据和代码捆绑到一起,避免了外界的干扰和不确定性。例如 C++中的 类,它定义了该集合中每个对象所共有的属性和方法。 2. 继承 继承是让某个...
  • python之多态

    2020-11-28 17:22:30
    python之多态一、什么是多态?同一种事物,有多种形态!class Animal: #同一类事物:动物def talk(self):passclass Cat(Animal): #动物的形态之一:猫def talk(self):print('喵喵喵')class Dog(Animal): #动物的形态之...
  • JavaJava名词解释

    2019-10-04 13:45:58
    Java|Java名词解释(1) 一、引入 ​ 最近笔者身边很多刚刚接触Java这门语言的萌新们问了我一些关于名词概念的问题,诸如:“喂喂喂,jdk是什么呀?”、“对了,抽象类是什么意思呢?”等等,确实,java语言中的概念...
  • 面向对象三大特性:封装、继承、多态 封装 概念: 将一些属性和相关方法封装在一个对象中,对外隐藏内部具体实现细节。 内部实现,外界不需要关心,外界只需要根据”内部提供的接口“去使用就可以。 好处: 使用...
  • Java名词解释(第1弹) 如有更好的解释,请评论提出,转载请注明出处 类 是对一类对象的描述,是面向对象程序设计的基本结构,包含数据域和操作这些数据的机制。 对象 对象是在其类模型基础上构造出的,是类的具体的...
  • #多态 -多态是指针对某个类型的方法调用,...向上转型的详细解释 : //Person为父类型 class Person { public void sayHello { System.out.println("class-Person Hello!"); } } class Individual extends Perso
  • 软件工程常见名词解释&概念题

    千次阅读 2019-04-19 19:48:20
     子类型多态(面向对象编程中的狭义多态)  使用继承机制实现  表现为很多不同的子类通过共同的父类联系在一起,通过父类表现统一的接口,通过子类表现不同的行为  程序员不需要预先知道对象的类型,具体...
  • Java基础名词解释

    2022-01-01 12:42:47
    JAVA基础名词解释 jdk:Java development kit,是程序员编写Java程序需要的软件 jre:Java run time environment,程序员运行Java程序的软件 Java se:Java standard edition,是桌面或者比较简单的服务器Java...
  • Java名词解释(第2弹) 如有更好的解释,请评论提出,转载请注明出处 父类 被直接或间接继承的类。 子类 由已存在的类派生出的新类。 方法覆盖 若子类中的方法与父类中的某一方法具有相同的方法名、返回类型...
  • 接口、多态

    2020-10-03 16:13:14
    02_接口的定义基本格式 接口就是多个类的公共规范。 接口是一种引用数据类型,最重要的内容就是其中的:抽象方法。 如何定义一个接口的格式: public interface 接口名称 { // 接口内容 } 备注:换成了关键字...
  • C++常用名词解释汇总

    千次阅读 2018-03-04 16:58:02
    C++常用名词解释汇总new运算符:对象创建的操作符。delete运算符:对象释放操作符,触发析构函数。内存泄露:操作堆内存时,如果分配了内存,就有责任回收它,否则这块内存就无法重新使用,称为内存泄漏。自动变量:...
  • java基础——多态 上次说完了类的继承,这次来说说多态,首先,我们学习一个新的知识...名词解析的解释有点生硬,那我们就用自己的话来解释多态,见名知义,就是多种形态,那是谁多种形态呢?java中主要就是类和对象
  • 名词解释

    2019-10-08 12:38:38
     实现多态的方法有:虚函数,抽象类,重载,复写,模板。 ---------------------------------------------------------- 引用:  是某一变量的别名,对引用的操作和对变量直接操作一样。声明方法: 类型...
  • 面向对象之名词解释

    千次阅读 2016-09-07 11:30:13
    多态有关的特性:重载(overload)、动态绑定(dynamic binding)、类属(generic 服务参量的类型可参数化) 面向对象的五大原则 单一职责原则 开放封闭原则 里氏替换原则 依赖倒置原则 接口隔离原则 ...
  • 多态

    2019-09-30 14:42:05
    什么是多态?所谓多态,是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定,而是在程序运行期间才确定,即一个引用变量倒底会指向哪个类的实例对象,该引用变量发出的方法...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,610
精华内容 3,044
关键字:

名词解释多态