村办计算深切.NET平台和C#编制程序

再三再四的股票总市值:

foreach(Object item in list)

7.深切明白多态

文件读写器

(1.)方法名与类名相同

return;

set访问器只写;get访问器只读。

然后建二个职工的成团,早先化职员和工人.
扔到集合里。就和=能够用集合的项点出职员和工人回家的方法传一个子类!
计算那正是子类指向父类!也正是所谓的里氏替换原则!

}

item.Key;

·抽象类不能够是密封的要么静态的

(二.)未有重返值

Console.WriteLine(dic.Key);

      {

看起来很不可名状,因为大家会意识在友好编制程序中时时会背离里氏替换原则,程序依旧跑的绝妙的。所以大家都会产生如此的疑难,假诺笔者非要不依据里氏替换原则会有怎样结果?

.NET框架具有五个重要组件:CL本田CR-V和FCL。(CL福睿斯是Common
Language Runtime即公共语言进行时;FCL是Framework Class
Library即框架类库)

{

此起彼伏:建立类之间的关联上,完结代码复用,方便系统的壮大。

方法重载

List<Object> list=new List<Oibject>();

抽象类和浮泛方法的利用

Delete()删除文件

C#中有八个重点字能够提现里氏替换原则:is和as操作符
is操作符用于检核对象和点名的档次是不是协作。
as操作符首要用于多个指标时期的类型转换。

示例:

string content=txtContent.Text;

}

·抽象类不能够直接被实例化

      foreach(XmlNode item in doc.ChildNodes)

object o=i;//装箱

public static void Main(string[] args)

抽象类和虚幻方法

    XmlDocument doc=new XmlDocument():

虚方法

父类类型做参数

.NET框架的体系布局

语法

指标交互

如何是多态

走访修饰符 virtual 重临类型 方法名()

示例 小型能源管理器

(1.)达成格局重写

}

myfs.Close();

}

FileStream 文件流对象=new FileStream(string filePath,FileMode fileMode);

 一.保障数据的安全性。

{

  1、哈希表(Hashtable)简述
     在.NET
Framework中,Hashtable是System.Collections命名空间提供的多个器皿,用于拍卖和呈现类似key/value的键值对,在那之中key常常可用来火速搜索,同时key是分别轻重缓急写;value用于存款和储蓄对应于key的值。Hashtable中key/value键值对均为object类型,所以Hashtable能够协助其余类型的key/value键值对.

//方法体

{  

(一.)集成模拟了切实世界关系,oop中强调任何皆对象,这契合大家面向对象编制程序的思维情势

值传递和引用传递

(叁.)在同一个类中

 

{

文件流

(二.)方法参数类型不一样大概参数个数分裂

怎样促成2个虚幻父类派生的子类
当从三个虚幻父类派生1个抽象子类时,子类将一而再父类的装有特征,包蕴它未落到实处的思梅止渴方法。抽象方法必须在子类中实现,除非她的子类也是抽象类。

 

 //方法体

重写虚方法

民用知道,他为啥叫对象间互动呢。因为是目的间开始展览的性质方法交互。而类之间展开的持续多态接口。

(三.)集成使程序结构更鲜明

抽象类和架空方法的使用

{

结构体:

无参构造和带参构造能够看成是艺术重载。

贰.base第3字和protected修饰符

只顾:抽象方法未有关闭的大括号,而是一贯跟了个“;”约等于说,它从不蕴涵方法执行逻辑的方法体!

当子类的法子重载父类的法丑时,方法的放权条件(即方法的形参)要比父类方法的输入参数更加宽松。

遍历

在1个软件系统中,子类能够替换父类出现的职责,而对软件的效益未有别的影响,就叫做里氏替换原则。

l  XML 被设计的宏旨是:是意味着数据,而非展现数据。

二.提供清晰的对外接口

引用类型包蕴string 数组,类和接口。

  九.文件操作

{

MessageBox.Show(“写入成功”);

示范: 先给多少个类: 1.父类,交通工具类。有一群属性。
二.小车类,继承父类。 三.地铁类,继承父类。
四.职员和工人类。职员和工人乘坐四通八达工具归家!职员和工人回家的章程,参数是父类对象!

文件和目录操作

拆箱和装箱

 用TreeView显示数据

一.构造函数

string path=txtFilePath.Text;

类定义了壹组概念模型,而指标是动真格的的实体。

概念时字段不能被赋初值。

 //方法体

不用new。注脚结构对象后务必给协会成员赋初值。

int j=(int)o;//拆箱

遍历

(2)集成的概念

②、哈希表的简练操作
在哈希表中添加贰个key/value键值对:HashtableObject.Add(key,value);
在哈希表中删去某些key/value键值对:HashtableObject.Remove(key);
从哈希表中移除全部因素:                HashtableObject.Clear(); 
认清哈希表是不是带有特定键key:         HashtableObject.Contains(key);
遍历

    doc.Load(“Engineer.xml”);

for(int i=0;i<list.Count;i++)

能够有字段,可以有法子。

系统活动给类分红三个无参构造函数。

FileStream myfs=new FileStream(path,FileMode.Open)

Move()移动文件

值类型包含基本数据类型,和枚举类型,结构体等。

 {

叁.带参构造函数

mysw.Close();

·抽象类中得以包含抽象成员,但非抽象类中不能

解析XMl文件

}

{

if(path.Equals(null)||path.Equals(“”))

构造函数的重载

StreamWriter mysw=new StreamWriter();

  

 若果基类中是未有参数的构造函数

MessageBox.Show(ex.Message);

int a=1;

    //方法体

值传递:传的是目的的值拷贝。(即函数内部参考消息数对象是调用时传递的靶子的栈中对象的正片。)
引用传递:传的是栈中对象的地方。(即函数内部参考音讯数对象与调用时传递的目的完全是同一栈中指标。)

{

}

瞩目:
抽象类提供的悬空方法,那么些点子唯有定义,怎么着贯彻都由抽象类的非抽象子类完结。

派生类隐式得到基类的除构造函数和析构函数以外的装有成员。

 单列泛型集合:

由于SE和PM都继承Employee,即SE is a Employee,PM is a Employee.

泛型最常见的用途是泛型集合,命名空间System.Collections.Generic
中包括了有的基于泛型的集合类,使用泛型集合类能够提供更加高的品种安全性,还有越来越高的品质,幸免了非泛型集合的再次的装箱和拆箱。 
   
很多非泛型集合类都有对应的泛型集合类,下边是常用的非泛型集合类以及相应的泛型集合类:

三.子类构造函数

多态

 

      }

三.使用集合组织有关数据

Console.WriteLine(dic.Value);

什么样贯彻二个华而不实父类派生的子类
当从三个空洞父类派生3个空洞子类时,子类将持续父类的有着特征,包罗它未兑现的架空方法。抽象方法必须在子类中落到实处,除非他的子类也是抽象类。

类图

值类型应用类型

is a的应用

File类和Directory类

双列泛型集合

隐式构造函数

     
.NET框架(.NET Framework),他是开发.NET应用程序的中坚基础。

File类常用的艺术

缓解集成带来的难题

例如: Father son=new Son();

l  XML ( eXtensible 马克up Language
)语言是一种可扩张的号子语言。个中的可扩张是相对HTML来说的。因为XML标签未有被预订义,须要用户自行定义标签。

                case “id”:

8.可增加标记性语言XML

非泛型集合类 泛型集合类
ArrayList List<T>
HashTable DIctionary<T>
Queue Queue<T>
Stack Stack<T>
SortedList SortedList<T>

抽象类与非抽象类的最重要不同:

mysw.Write(content);

一.什么样是后续

持续概述

                  Console.WriteLine(node.InnerText);

{

  前言:学习C#编制程序应该有多少个月了,作为多个菜鸟,未有身份来评价怎么着。唯有对友好所学进行3个总计,大概有不谨慎的地方,万望谅解。

 }

Exites(string path) 用于检查钦定文件是或不是存在

贯彻多态

子类能够扩充父类的效能,但无法更改父类原有的职能。
子类能够实现父类的架空方法,但不可能掩盖父类的非抽象方法。
子类中能够扩大和谐故意的艺术。

}

多态:相同的方法调用可实现不一致的贯彻格局。

抽象类的定义

txtContent.Text=content;

FileStream nyfs=new FileStream(path,FileMode.Create)

{

  Console.WriteLine(list[i]);

}

走访修饰符 类名(参数列表)

 陆.初识继承和多态

 
       一·深入.NET框架

在vs中机动属性prop+双击Tab键

public class Person
{
protected string ssn = "111-222-333-444" ;
protected string name = "张三" ;
public virtual void GetInfo() {
Console.WriteLine("姓名: {0}", name) ;
Console.WriteLine("编号: {0}", ssn) ;
}
}
class Employee: Person
{
public string id = "ABC567EFG23267" ;
public override void GetInfo() {
// 调用基类的GetInfo方法:
base.GetInfo();
Console.WriteLine("成员ID: {0}", id) ;
}
}

Dictionary<object,object>
dic=new Dictionary<object,object>();

当子类的方法实现父类的抽象方法时,方法的后置条件(即方法的重临值)要比父类更严苛。

                   break;

里氏替换原则

操作XML的方法

架空方爱沙尼亚语法

选取virtual关键字修饰的艺术,称为虚方法。虚方法有方法体

假定基类中是绝非参数的构造函数,在派生类中能够自定义有参数的构造函数

foreach(KeyValuePair<object,object> item in dic)

}

 

XmlDocument doc = new XmlDocument();
            doc.Load("北京电视台.xml");
            XmlNode root = doc.DocumentElement;
            //找根节点  
            foreach (XmlNode item in root.ChildNodes)//遍历子节点
            {
                if(item.Name.Equals("tvProgramTable"))//判断条件是节点的Name是否是"tvProgramTable"
                {
                    foreach (XmlNode items in item.ChildNodes)//遍历子节点的子节点
                    {
                        TvProgram Tp = new TvProgram();
                        Tp.PlayTime = Convert.ToDateTime(items["playTime"].InnerText);
                        Tp.Meridien = items["meridien"].InnerText;
                        Tp.Path = items["path"].InnerText;
                        Tp.ProgramName = items["programName"].InnerText;
                        ProgramList1.Add(Tp);//绑定到集合
                    }
                }

            }
TreeNode minenode = new TreeNode();
            minenode.Text = "我的电视台";

            //bind
            tvList.Nodes.Add(minenode);

            //根节点
            TreeNode root = new TreeNode();
            root.Text = "所有电视台";
            //bind
            tvList.Nodes.Add(root);

            ChannelManager manager = new ChannelManager();
            manager.ResolveChannels();
            List<ChannelBase> list = manager.List;
            foreach (ChannelBase item in list)
            {
                TreeNode tn = new TreeNode();
                tn.Text = item.ChannelName;
                tn.Tag = item;
                root.Nodes.Add(tn);

            }

}

访问修饰符 类名()

空洞方法是一个并未有完成的章程,通过在定义方法时扩大最主要字abstract能够评释抽象方法。

结果就是:你写的代码出难点的可能率将会大大扩充。

  Console.WriteLine(item);

什么读写文件

item.Values;

三.类内部能够随心所欲修改,不影响其余类。

copy()复制文件

图片 1

类和对象

           switch(node.Name)

继承、封装和多态是面向对象编制程序的首要性特点。
其成员被持续的类叫基类也称父类,继承其成员的类叫派生类也称子类。

foreach(Object item in dic.Keys)

StreamWriter 写入器

引用类型作为参数时:
壹、在修改变量自个儿时,结果类似于值传递,即不会转移传递前的变量的值
2、在改动变量的属性或字段时,才是引用传递,会影响到传递前的变量的值
3、参数使用了ref后,才是真正的引用传递,不管修改变量本人照旧修改变量的性质或字段,都会影响到传递前的变量的值

content=mySr.ReadToEnd();

using System;
using System.Collections.Generic;
using System.Text;
using System.Collections;
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            ArrayList list = new ArrayList();

            Console.WriteLine("遍历方法一:");
            foreach (int item in list)//不要强制转换
            {
                Console.WriteLine(item);//遍历方法一
            }

            Console.WriteLine("遍历方法二:");
            for (int i = 0; i < list.Count; i++)//数组是length
            {
                int number = (int)list[i];//一定要强制转换
                Console.WriteLine(number);//遍历方法二

            }
        }
    }
}

派生类只可以有3个平素基类,所以C#并不协理多重继承,但一个基类能够有两个一贯派生类。
继续是足以传递的。

化解乱码难题

语法

.NET框架宗旨类库及其作用

 MessageBox.Show(“文件的路子不为空”);

            {

初阶后就是这么能够读出本身硬盘上的事物!

直面对象的三大特色

  Console.WriteLine(dic[item].Value);

语法: 访问修饰符 abstract class 类名{}

}

  图片 2图片 3

 

(一)隐式调用父类构造函数

二.深入C#数据类型

个体成员其实已经被持续了,不过它们却不能被访问,因为个人成员只好被声称它们的类或结构体中才可访问,所以看上去像是未有被接二连三。**

try

只要派生类的基类也是派生类,则每一个派生类只需担当其一向基类的构造,不承担直接基类的组织,
并且其实施构造函数的依次是从最下面包车型大巴基类开始的,直到最后一个派生类甘休。

引入using.System.IO;

catch(Exception ex)

(2.)定义父类变量

            }

 
支持C#、VB、.NET、c++、等语言的开支,也正是我们所说的跨语言开发。

二.无参构造函数的

{

多态按字面包车型地铁意味正是“多样模样”,指同一操作功用差异的对象时,能够有分化的解释,发生差异的结果。

图片 4

(三.)主要成就指标初步化学工业作

各类类都有谈得来的性状和功能,大家把它们封装为属性和措施。对象之间通过质量和艺术举办交互。能够认为方法的参数及方法的重回值都以目的间互动传递音信。

 继承的施用

(贰.)继承达成了代码复用

foreach(Object item in dic.Values)

 Console.WriteLine(item);

{

封装

4.深入类的点子

(一)移除类的冗余代码

foreach(DictionaryEntry item in Hashtable)

访问修饰符 abstract 重回值类型 方法名();

假如叁个类不与实际的事物相联系,而只是抒发1种浮泛的概念,仅仅是作为其派生类的1个基类,那样的类就是抽象类,在抽象类中扬言方法时,假诺加上abstract时正是空泛方法

语法

假若基类定义了蕴藏参数的构造函数,那么此构造函数必须被实施,且在派生类中落实该构造函数,此时我们能够利用base关键字

做客修饰符 override 再次来到值类型 方法名()

streamWriter mysw=new StreamWriter(myfs);

 Console.WriteLine(item);

     XmlNode root=new XmlNode();

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

namespace Chap09_资源管理器
{
    class MyFile
    {
        public string FileName { get; set; }
        public long FileLength { get; set; }
        public string FileType { get; set; }
        public string FilePath { get; set; }
    }
}
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.IO;
using System.Diagnostics;

namespace Chap09_资源管理器
{
    public partial class FrmMain : Form

    {
        public FrmMain()
        {
            InitializeComponent();
        }

        private void FrmMain_Load(object sender, EventArgs e)
        {
            DriveInfo[] di = DriveInfo.GetDrives();
            foreach (DriveInfo item in di)
            {
                TreeNode tn = new TreeNode(item.Name);
                tn.Tag = item.Name;
                tvList.Nodes.Add(tn);

            }


        }
        public void BindInfo(TreeNode node)
        {
            try
            {
                lvList.Items.Clear();
                DirectoryInfo dir = new DirectoryInfo(node.Tag.ToString());
                DirectoryInfo[] dirs = dir.GetDirectories();
                foreach (DirectoryInfo item in dirs)
                {
                    TreeNode tn = new TreeNode();
                    tn.Text = item.Name;
                    tn.Tag = item.FullName;
                    node.Nodes.Add(tn);
                }
                FileInfo[] fi = dir.GetFiles();
                List<MyFile> files = new List<MyFile>();
                foreach (FileInfo item in fi)
                {
                    MyFile mf = new MyFile();
                    mf.FileName = item.Name;
                    mf.FileLength = item.Length;
                    mf.FileType = item.Extension;
                    mf.FilePath = item.FullName;
                    files.Add(mf);
                }
                foreach (MyFile item in files)
                {
                    ListViewItem items = new ListViewItem(item.FileName);
                    items.SubItems.Add(item.FileLength.ToString());
                    items.SubItems.Add(item.FileType);
                    items.SubItems.Add(item.FilePath);
                    lvList.Items.Add(items);
                }

            }
            catch (Exception ex)
            {

                MessageBox.Show(""+ex.Message);
            }

        }

        private void tvList_AfterSelect(object sender, TreeViewEventArgs e)
        {

            TreeNode node = this.tvList.SelectedNode;
            this.BindInfo(node);

        }

        private void lvList_DoubleClick(object sender, EventArgs e)
        {
            Process.Start(lvList.SelectedItems[0].SubItems[3].Text);
        }

        private void 复制ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            FolderBrowserDialog fbd = new FolderBrowserDialog();
            DialogResult result = fbd.ShowDialog();
            string sourcePath = lvList.SelectedItems[0].SubItems[3].Text;
            string desPath = null;
            if(result==DialogResult.OK)
            {
                desPath = fbd.SelectedPath;
                desPath += "\\" + lvList.SelectedItems[0].SubItems[0].Text;
                File.Copy(sourcePath,desPath);
                MessageBox.Show("复制成功");
            }

        }

        private void 删除ToolStripMenuItem_Click(object sender, EventArgs e)
        {
            lvList.Items.Clear();
           string deletePath=lvList.SelectedItems[0].SubItems[3].Text;
            File.Delete(deletePath);
            MessageBox.Show("删除成功");
        }
    }
}

(贰)呈现调用父类构造函数

好了就写到那了。总计到那边了。

壹、XML是怎么着?功能是如何?

{

(1.)方法名相同

卷入:保障对象自我数据的完整性和安全性

StreamReader mySr=new StreamReader(myfs,Encoding.Default);

语法

System.Collections 命名空间包罗接口和类,那些接口和类定义种种对象(如列表、队列、位数组、哈希表和字典)的联谊。
System.Collections.Generic 命名空间包括定义泛型集合的接口和类,泛型集合允许用户创设强类型集合,它能提供比非泛型强类型集合更加好的类型安全性和总体性。
System.Collections.Specialized 命名空间包含专用的和强类型的聚集,例如,链接的列表词典、位向量以及只含有字符串的集结。

相关文章