fun main(args: Array<String>) {	var rect01 = Rect(20,10)	println("矩形的宽度:"+rect01.width+",矩形的高度:"+rect01.height)}class Rect(var width:Int,var height:Int)fun main(args: Array<String>...            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2022-06-06 13:42:33
                            
                                201阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            I . 创建简单类 ( 整型字段 )II . 创建简单类 ( 整型字段 + 字符串字段 )III . 类方法定义IV . 封装V . 继承VI . 多态 与 抽象类            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2022-03-09 10:17:03
                            
                                314阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            cn.kotlin.kotlin_oop06/** * 定义描述手机的Interface */interface Inte            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                            精选
                                                        
                            2023-06-22 14:15:25
                            
                                428阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            继承: 比较简单,直接看如何使用,这里以父亲与儿子的关系为例: 接着定义儿子并且继承父亲,如下: 是用":"号来继承的,但是此时报错了,看下错误提示: 在kotlin的类并非是人人都可以继承的,从提示来看说Father是一个final类型的,好奇怪,也没对Father类声明为final呀,要想解决这            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2018-01-18 10:38:00
                            
                                102阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            /** * 抽象的类 */abstract class Human(var name:String) {    abstract fun eat()       abstract fun read()}/** * 实现的类 */ class Man(name:String):Human(name) {    override fun read() {        println            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2021-06-03 21:15:00
                            
                                199阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            Kotlin的继承与多态机制是构建可复用、可扩展程序的核心。继承允许一个类获取另一个类(父类)的属性和方法,多态则通过方法重写实现不同类对同一            
                
         
            
            
            
            上篇博文讲了k抽象 */abstract class Person {    /**     * 抽象行为用abstract修            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2023-06-19 14:48:43
                            
                                80阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            多态(polymorphism)字面上意思--多种形态,即同一种方法的行为随上下文而异。维基百科:Polymorphism (computer science), the ability incomputer programming to present the same interface for differing underlyingforms (data types). 1、函数            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2014-09-03 15:50:45
                            
                                2046阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            多态分为两种:通用的多态和特定的多态。两者的区别是前者对工作的类型不加限制,允许对不同类型的值执行相同的代码;后者只对有限数量的类型有效,而且对不同类型的值可能要执行不同的代码。 通用多态又分为参数多态(parametric)和包含多态(Inclusion Polymorphism);特定多态分为过            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2019-02-26 08:46:00
                            
                                854阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            一、前言      多态在面向对象中起着非常重要的作用。多态性的官方介绍是作用于不同的对象的同一            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2023-05-06 16:25:20
                            
                                528阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            类型转换:instanceof运算符:多态 例子://向上转型:限定功能使用,提高扩展性
Animal a = new cat();//自动类型提升
abstract class Animal{
    abstract void eat();
}
class Cat extends Animal{
    public void eat(){
        System.out.println            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                            精选
                                                        
                            2013-11-24 23:04:07
                            
                                321阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            多态概念:一种形式有多种实现形态静态多态:编译器在编译期间完成的,根据函数实参的类型(可能会进行隐式类型转换),可推断出要调用哪个函数,如果有对应的函数就调用该函数否则出现编译错误。(比如函数重载)实现多态调动:基类必须加virtual关键字修饰,派生类可加可不加。(虚函数实现)动态绑定条件(1)必须是虚函数(2)通过基类类型的引用或指针调用 赋值运算符重载、静态成员函数、友元函数不能定            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2016-04-20 17:39:30
                            
                                457阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            使用父类对象的地方都可以使用子类的对象,这就是通常所说的多态。即第一个displayObject方法使用参数圆,第二个使用参数矩形。因为圆和矩形都是Geometric的子类。具体代码请参照:http://10541556.blog.51cto.com/10531556/1880621package circle;
public class main {            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2016-12-08 10:58:12
                            
                                630阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            多态可以理解为一个事物的多种形态,也就是说一个子类对象既可以给子类成员赋值,也可以给父类的成员赋值。多态的最终体现为父类的引用变量指向子类对象。多态的前提是必须有子父类关系或者是实现接口的关系,否二无法完成多态。在创建多态的父类引用变量调用方法时,运行的是子类重写后的方法。Person p = new Student();p.show();该方法调用的是子类重写后的方法多态的定义格式定义多态对象的            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2017-12-19 12:20:52
                            
                                754阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            what:同一个对象,在不同时刻表现出来的不同形态。how:要有继承或实现关系要有方法的重写要有父类引用指向子类对象why:利:提高程序的扩展性。定义方法时候,使用父类型作为参数,在使用的时候,使用具体的子类型参与操作。弊:不能使用子类的特有成员。向上转型:父类引用指向子类对象就是向上转型。格式:父类类型变量名=new子类类型();如:Animalanimal=newCat();向下转型:格式:子            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2020-11-03 21:28:38
                            
                                349阅读
                            
                                                        
                                点赞
                            
                                                                             
                 
                
                             
         
            
            
            
            1 多态的基本概念多态是C++面向对象三大特性之一多态分为两类静态多态: 函数重载 和 运算符重载属于静态多态,复用函数名动态多态: 派生类和虚函数实现运行时多态静态多态和动态多态区别:静态多态的函数地址早绑定  -  编译阶段确定函数地址动态多态的函数地址晚绑定  -  运行阶段确定函数地址下面通过案例进行讲解多态class Animal
{
public:
	//Speak函数就是虚函数
	/            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2021-03-05 15:24:35
                            
                                117阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            多态同一方法可以根据发送对象的不同而采用多种不同的行为方式。一个对象的实际类型是确定的,但可以指向对象的引用的类型有很多(父类,有关系的类) 多态存在的条件有继承关系子类重写父类方法父类引用指向子类对象 注意:多态是方法的多态,属性没有多态。            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2021-04-17 14:51:24
                            
                                264阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            一个方法可以根据发送对象的不同而采用很多种不同方式一个对象的实际类型是确定的 但可以指向对象的引用类型多态存在的条件有继承关系子类重写父类方法父类引用指向子类对象`//子类
@Override//方法重构
public void run() {
    System.out.println("son");
}
public void eat(){
    System.out.println("e            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2021-05-30 08:02:22
                            
                                81阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            声明类Shape以及它的3个派生类:Circle、Square、Rectangle,用虚函数分别计算几种图形的面积、周长,编写程序,建立基类指针数组,每个指针均指向一个派生类对象,利用基类指针遍历元素对象,求取所有图形面积之和。请绘制UML类图。 1 //Shape.h 2 #ifndef _SHA ...            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2021-06-18 01:10:00
                            
                                107阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            同一方法根据发送对象的不同而采用多种不同的行为方式。 多态存在的条件: 有继承关系 子类重写父类方法 父类引用指向子类对象 public class Person { public void run(){ System.out.println("走"); }}public class Studen ...            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2021-07-26 19:20:00
                            
                                76阅读
                            
                                                                                    
                                2评论