Abstract (抽象类、接口、重写、覆写、重载)

最新推荐文章于 2022-03-31 10:33:14 发布
最新推荐文章于 2022-03-31 10:33:14 发布
阅读量315 收藏
点赞数
文章标签： 移动开发
原文链接：http://www.cnblogs.com/zhengqian/p/8493256.html
版权 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyAbstract.Abstract
{
    /// <summary>
    /// 抽象类是一个类，里面可以包含一切类可以包含的
    /// 抽象成员 必须包含在抽象类里面，抽象类还可以包含普通成员
    /// 继承抽象类后，必须显示的override其抽象成员
    /// 抽象类不能直接实例化，声明的对象只能使用抽象类里的方法，不能用子类新增的方法
    /// 父类只有一个
    /// is a
    /// </summary>
    public abstract class BasePhone
    {
        public int Id { get; set; }
        public string Name = "123";
        public delegate void DoNothing();
        public event DoNothing DoNothingEvent;

        public void Show()
        {
            Console.WriteLine("这里是Show1");
        }
        public virtual void ShowVirtual()
        {
            Console.WriteLine("这里是Show");
        }

        /// <summary>
        /// 品牌
        /// </summary>
        /// <returns></returns>
        public abstract string Brand();

        /// <summary>
        /// 系统
        /// </summary>
        /// <returns></returns>
        public abstract string System();

        /// <summary>
        /// 打电话
        /// </summary>
        public abstract void Call();


        /// <summary>
        /// 拍照
        /// </summary>
        public abstract void Photo();

        public abstract void Do<T>();
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyAbstract.Abstract
{
    /// <summary>
    /// 接口不是类，里面可以包含属性、方法、事件   不能包含字段，委托，不能用访问修饰符
    /// 接口只能包含没有实现的方法
    /// 实现接口的话，必须实现全部方法
    /// 接口不能直接实例化，声明的对象只能使用接口里的方法，不能用子类新增的方法
    /// 接口可以实现多个
    /// can do
    /// </summary>
    public interface IExtend
    {
        //event Action DoNothingEvent;
        //int Id { get; set; }
        void Game();
        //List<>
    }

    public interface IPay
    {
        void Pay();
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyAbstract.Abstract
{
    public class iPad : IExtend, IPay
    //: BasePhone
    {
        public void Game()
        {
            throw new NotImplementedException();
        }

        public void Pay()
        {
            throw new NotImplementedException();
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyAbstract.Abstract
{
    /// <summary>
    /// 手机
    /// </summary>
    public class iPhone : BasePhone, IExtend, IPay
    {
        /// <summary>
        /// 品牌
        /// </summary>
        /// <returns></returns>
        public override string Brand()
        {
            return "iPhone";
        }

        /// <summary>
        /// 系统
        /// </summary>
        /// <returns></returns>
        public override string System()
        {
            return "IOS";
        }

        /// <summary>
        /// 打电话
        /// </summary>
        public override void Call()
        {
            Console.WriteLine("User{0} {1} {2} Call", this.GetType().Name, this.Brand(), this.System());
        }

        /// <summary>
        /// 拍照
        /// </summary>
        public override void Photo()
        {
            Console.WriteLine("User{0} {1} {2} Call", this.GetType().Name, this.Brand(), this.System());
        }


        public override void Do<T>()
        {

        }

        public void Game()
        {
            throw new NotImplementedException();
        }

        public void Pay()
        {
            throw new NotImplementedException();
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyAbstract.Abstract
{
    /// <summary>
    /// 手机
    /// </summary>
    public class Lumia : BasePhone,IExtend
    {
        /// <summary>
        /// 品牌
        /// </summary>
        /// <returns></returns>
        public override string Brand()
        {
            return "Nokia";
        }

        /// <summary>
        /// 系统
        /// </summary>
        /// <returns></returns>
        public override string System()
        {
            return "Winphone";
        }

        /// <summary>
        /// 打电话
        /// </summary>
        public override void Call()
        {
            Console.WriteLine("User{0} {1} {2} Call", this.GetType().Name, this.Brand(), this.System());
        }

        /// <summary>
        /// 拍照
        /// </summary>
        public override void Photo()
        {
            Console.WriteLine("User{0} {1} {2} Call", this.GetType().Name, this.Brand(), this.System());
        }

        public void Metro()
        {
            Console.WriteLine("This is Metro");
        }
        public override void Do<T>()
        {

        }

        public void Game()
        {
            throw new NotImplementedException();
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyAbstract.Abstract
{
    /// <summary>
    /// 手机
    /// </summary>
    public class Mi : BasePhone
    {
        /// <summary>
        /// 品牌
        /// </summary>
        /// <returns></returns>
        public override string Brand()
        {
            return "XiaoMi";
        }

        /// <summary>
        /// 系统
        /// </summary>
        /// <returns></returns>
        public override string System()
        {
            return "Android";
        }

        /// <summary>
        /// 打电话
        /// </summary>
        public override void Call()
        {
            Console.WriteLine("User{0} {1} {2} Call", this.GetType().Name, this.Brand(), this.System());
        }

        /// <summary>
        /// 拍照
        /// </summary>
        public override void Photo()
        {
            Console.WriteLine("User{0} {1} {2} Photo", this.GetType().Name, this.Brand(), this.System());
        }
        public override void Do<T>()
        {

        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyAbstract.Polymorphism
{
    /// <summary>
    /// 普通方法是由编译时决定的
    ///   虚方法是由运行时决定的
    /// </summary>
    public class Poly
    {
        public static void Test()
        {
            Console.WriteLine("*******************************************");
            Console.WriteLine("*******************************************");
            Console.WriteLine("*******************************************");
            ParentClass instance = new ChildClass();
            Console.WriteLine("下面是instance.CommonMethod()");
            instance.CommonMethod();
            Console.WriteLine("下面是instance.VirtualMethod()");
            instance.VirtualMethod();
            Console.WriteLine("下面是instance.AbstractMethod()");
            instance.AbstractMethod();


            Console.WriteLine("*******************************************");
            Console.WriteLine("*******************************************");
            Console.WriteLine("*******************************************");
        }
    }

    #region abstract
    public abstract class ParentClass
    {
        /// <summary>
        /// CommonMethod
        /// </summary>
        public void CommonMethod()
        {
            Console.WriteLine("ParentClass CommonMethod");
        }

        /// <summary>
        /// virtual  虚方法  必须包含实现 但是可以被重载
        /// </summary>
        public virtual void VirtualMethod()
        {
            Console.WriteLine("ParentClass VirtualMethod");
        }

        public virtual void VirtualMethod(string name)
        {
            Console.WriteLine("ParentClass VirtualMethod");
        }

        //public override bool Equals(object obj)
        //{
        //    return base.Equals(obj);
        //}

        public abstract void AbstractMethod();
    }

    public class ChildClass : ParentClass
    {
        /// <summary>
        /// new 隐藏
        /// </summary>
        public new void CommonMethod()
        {
            Console.WriteLine("ChildClass CommonMethod");
        }

        public void CommonMethod(string name)
        {
            Console.WriteLine("ChildClass CommonMethod");
        }
        //public void CommonMethod(int id)
        //{
        //    Console.WriteLine("ChildClass CommonMethod");
        //}
        //public void CommonMethod(int id, string name)
        //{
        //    Console.WriteLine("ChildClass CommonMethod");
        //}
        public void CommonMethod(int id, string name = "", string des = "", int size = 0)
        {
            Console.WriteLine("ChildClass CommonMethod");
        }
        public void CommonMethod(string name, int id)
        {
            Console.WriteLine("ChildClass CommonMethod");
        }

        /// <summary>
        /// virtual 可以被覆写
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public override void VirtualMethod()
        {
            Console.WriteLine("ChildClass VirtualMethod");
            base.VirtualMethod();
        }

        public sealed override void AbstractMethod()
        {
            Console.WriteLine("ChildClass AbstractMethod");
        }
    }

    public class GrandClass : ChildClass
    {

        //public override void AbstractMethod()
        //{
        //    base.AbstractMethod();
        //}

        public override void VirtualMethod()
        {
            base.VirtualMethod();
        }
    }
    #endregion abstract

}
using MyAbstract.Abstract;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyAbstract
{
    /// <summary>
    /// 1 作业讲解
    /// 2 封装继承多态
    /// 3 抽象类接口
    /// 4 重写overwrite(new)  覆写override 重载overload(方法) 
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                Console.WriteLine("欢迎来到.net高级班vip课程，今天是Eleven老师为大家带来的接口抽象类课程");
                Student student = new Student()
                {
                    Id = 423,
                    Name = "假洒脱"
                };
                {
                    BasePhone phone = new Lumia();
                    //student.PlayLumia(phone);
                    student.PlayPhone(phone);
                }
                {
                    //BasePhone phone = new BasePhone();
                    //BasePhone phone = new Lumia();
                    //phone.Metro();

                    IExtend phone = new iPhone();
                    //IExtend phone = new IExtend();
                    //phone.Call();
                }
                {
                    BasePhone phone = new iPhone();
                    phone.Call();
                    //student.PlayIPhone(phone);
                    student.PlayPhone(phone);
                }
                Polymorphism.Poly.Test();

            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
            Console.Read();
        }
    }
}
using MyAbstract.Abstract;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyAbstract
{

    public class People
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }

    public class Student : People
    {
        private int Tall { get; set; }

        //public void Play<T>(T t) where T:
        //{
        //    Console.WriteLine("This is {0} play {1}", this.Name, lumia.GetType());
        //    t.Brand();
        //    t.Call();
        //    t.Photo();
        //}

        public void PlayPhone(BasePhone phone)
        {
            Console.WriteLine("This is {0} play {1}", this.Name, phone.GetType());
            phone.Brand();
            phone.Call();
            phone.Photo();
        }

        public void PlayLumia(Lumia lumia)
        {
            Console.WriteLine("This is {0} play {1}", this.Name, lumia.GetType());
            lumia.Brand();
            lumia.Call();
            lumia.Photo();
        }
        public void PlayIPhone(iPhone lumia)
        {
            Console.WriteLine("This is {0} play {1}", this.Name, lumia.GetType());
            lumia.Brand();
            lumia.Call();
            lumia.Photo();
        }

        
    }
    public class Teacher : People
    {
        private int Tall { get; set; }

        public void PlayLumia(Lumia lumia)
        {
            Console.WriteLine("This is {0} play {1}", this.Name, lumia.GetType());
            lumia.Brand();
            lumia.Call();
            lumia.Photo();
        }
    }
}

 

转载于:https://www.cnblogs.com/zhengqian/p/8493256.html

weixin_33923148
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
.net基础面试
06-02
#### 一、抽象类与接口的区别及应用场景 **1.1 抽象类** - **定义**: 抽象类是一种不可以被实例化的类，通常包含抽象方法，但也可能包含具体实现。 - **应用场景**: - 当需要提供一些共享的行为时，比如一些通用的...
Visual C#程序员面试基础问题和答案.doc
02-21
15. **抽象类（abstract class）**：抽象类是一种不能被实例化的类，通常包含抽象方法（没有实现的方法），子类必须实现所有抽象方法才能被实例化。 16. **何时声明抽象类**：当类包含抽象方法或未实现父类的抽象...
abstract函数必须重写
MyLoveGame的专栏
05-13 2690
先举个列子，某工程公司要建立一座大楼，首先要绘制大楼图纸，图纸中绘制的内容很多例如窗口，门，天花板等；然后工人按照图纸建立大楼。 其中图纸就是抽象类，窗口、门、天花板就是抽象函数 如果只写了抽象函数没人现实就没有意义了；只画一张图纸还玩个P啊。 抽象类搭建框架时，具体实现可以不理会，直接抛给子类去实现；父类负责规范化处理即可 简单的列子（刚才讲的是图纸建立大
关于方法重写、abstract 与final 的知识点总结
yff933的博客
12-01 520
方法重写的规定： 有继承；方法名与父类名一样；形参与父类中的方法一致；返回值类型   ------------------------------------------------------------------------------------------------------------------------------------------------------
java抽象类重载,在Java中使用抽象类进行方法重载的困惑
weixin_34122028的博客
02-13 156
abstract class Cell {public abstract Q getValue(); // abstract method}class Cell1 extends Cell {public Integer getValue() {// abstract method implementationreturn 0;}}class Cell2 extends Cell {public ...
抽象方法(abstract method) 和 虚方法 (virtual method), 重载(overload) 和 重写(override)的区别于联系...
weixin_30722589的博客
07-06 369
1. 抽象方法 (abstract method) 在抽象类中，可以存在没有实现的方法，只是该方法必须声明为abstract抽象方法。 在继承此抽象类的类中，通过给方法加上override关键字来实现此方法. 由于该abstract method (抽象方法)是没有实现的方法，所以在子类中必须使用override关键字来重写此方法 抽象方法不提供自身的实现，并且强制子类重...
Java杂记2--abstract类与接口
heyzqt
01-09 531
1.对象的上转型对象 假如A类是B类的父类，当用子类创建一个对象，并把对象的引用放到父类的对象中。 如： A a=new B(); 或 A a; B b=new B(); a=b; 称a是b的上转型对象 有如下特点： （1）上转型对象不能操作子类新增的成员变量，不能调用子类新增的方法。 （2）上转型对象可以访问子类继承或隐藏的成员变量，也可调用子类继承的方法或子类重写的方法。
C#面试题,C#面试经典题
05-18
15. 什么是抽象类（abstract class）？ 答案：一种不可以被实例化的类。抽象类中一般含有抽象方法，当然也可有具体实现。继承类只有实现过所有抽象类的抽象方法后才能被实例化。 16. 何时必须声明一个类为抽象类？...
Java面试宝典新人版
10-31
多态是通过方法重载（Overload）和方法重写（Override）实现的，以及接口和抽象类的使用。 24. **abstractclass与interface的区别**： 抽象类可以包含字段、构造器、方法（包括抽象方法和非抽象方法）；接口只能...
,NET概念问题总结.doc
06-06
3. 抽象类（abstract class）： 抽象类是一种不能被实例化的类，它可以包含抽象方法（没有实现的方法）和非抽象方法（已有实现的方法）。抽象类通常作为基类使用，供子类继承并实现其抽象方法。 4. 接口...
方法的重载(Overloading)与重写(Override) Abstract(抽象) 和 Final(最终)关键字
qq_16733389的博客
04-09 804
方法的重写 方法的重写有两个约束条件： 一、（出现在继承中，处于子类中）在子类中，重写的方法必须与父类中的被重写的方法完全相同，局限于（方法的名字，方法的返回值，方法的参数）完全一致。 二、子类中重写的方法、访问修饰符可以与父类相同或者大于父类。 方法重写后，在调用子类中被重写的方法时，会优先调用子类中的被重写的方法。 访问权限修饰符 修饰符 本类 同包 非同包子类 其他 priv...
Java面向对象之继承、多态（重写方法、abstract、final）
pojpoj的博客
06-21 806
一、继承的优点和实现方法   1. 语法：修饰符 子类名 extends 父类{    }    若修饰符是public，则该类在整个项目中可见；若无public修饰符，则该类只在该包可见。    在定义一个类时，没有使用extends关键字，那么这个类直接继承Object类，所有对象都继承这个类的方法。   2.继承的内容        2.1继承public和protected修饰的属性和方法...
抽象方法（abstract class)与接口(interface)比较
D.K专栏
03-28 1323
抽象方法（abstract class)与接口(interface)比较
学习笔记——覆写（方法、属性）
weixin_45176509的博客
10-26 218
定义：子类与父类产生继承关系以后，会继承父类的全部操作。如果子类发现父类不足，但是需要保留父类属性和方法，就进行覆写。 方法覆写 方法的覆写：当子类定义了与父类方法名称相同，参数类型及个数完全相同的时候就称为覆写。 例子： class Lianjie{ public void connect(){ System.out.println("【父类】连接所有资源"); } } class Lian...
Java中抽象类与方法的重写
热门推荐
qq_49641620的博客
11-10 1万+
1. 抽象类 关键字：abstract 类：用来描述一类具体的事物 抽象类：抽象的、模糊的、不具体的类 在Java的普通类中是不允许多继承的，原因是会出现调用 不明确的问题; 总结：父类中的功能是不能删除的，但其形式是不需要的（没有存在的意义），此时就可以将父类中功能的 具体实现 形式 给删掉; 类的具体实现：创建对象 抽象方法存在的意义是什么？ 用于定义功能，明确该类具备此功能-----规则 特点： 1.抽象类可以有抽象方法，也可以有非抽象的方法 2.抽象类中可以有构造器，但是不能创建
抽象类实现接口时可以重写接口里部分的方法或者不重写接口中的方法
a16696747377的博客
03-31 3852
抽象类实现接口时可以重写接口里部分的方法或者不重写接口中的方法
Abstract与哪些关键字不能共存？为什么？
weixin_42601731的博客
04-05 695
abstract::表明希望被重写，即该类中的方法被继承后需要重写。 1.private 被private修饰的方法，子类不能继承到，故不能重写，也就不能共存 2.final final修饰的类不能被继承，方法不能被重写，变量不能更改值，故不能共存 3.static static能被实例化直接调用，即不需要依赖对象就可进行访问，而abstract不能被实例化，故不能共存 4.…… ...
java 接口 抽象类 继承 重载 重写 多态
清露草木的博客
07-16 4384
4.1 抽象类         在面向对象领域由于抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能实例化的。     同时，抽象类体现了数据抽象的思想，是实现多态的一种机制。它定义了一组抽象的方法，至于这组抽象方法的具体表现形式有派生类来实现。同时抽象类提供了继承的概念，它的出发点就是为了继承，否则它没有存在的任何意义。所以说定义的抽象类一定是用来继承的，同时在一个以抽象...
Java学习笔记：面向对象、继承与多态
"Java学习笔记包含了面向对象编程的多个核心概念，如继承、方法重写、属性覆盖、super关键字的使用、final关键字的作用、抽象类的定义与使用、接口的实现以及对象的多态性。" Java学习笔记深入探讨了面向对象编程的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值