Revisión del duodécimo día
namespace 复习
{
class Program
{
static void Main(string[] args)
{
/*
Lisi<T>
Dictionary<K,T>
拆装箱
装箱：值类型转为引用类型
拆箱：引用类型转为值类型
应该尽量避免在代码中发生
文件流
FileStream StreamReader和StreamWrite
多态：虚方法、抽象类、接口
虚方法
抽象类
*/
//List<int> list = new List<int>();
//Dictionary<int, string> dic = new Dictionary<int, string>();
//dic.Add(1, "张三");
//dic[2] = "李四";
//foreach (KeyValuePair<int ,string> kv in dic)
//{
// Console.WriteLine("{0}----{1}", kv.Key, kv.Value);
//}
//Console.ReadKey();
//File FileStream StreamReader StreamWrite
//using (FileStream fsRead = new FileStream("1.txt", FileMode.OpenOrCreate, FileAccess.Read))
//{
// byte[] buffer = new byte[1024 * 1024 * 5];
// int r = fsRead.Read(buffer, 0, buffer.Length);
// string s = Encoding.UTF8.GetString(buffer, 0, r);
// Console.WriteLine(s);
//}
//Console.ReadKey();
//using (FileStream fsWrite = new FileStream(@"C:\Users\Administrator\Desktop\new.txt", FileMode.OpenOrCreate, FileAccess.Write))
//{
// string s = "今天的内容有点多啊";
// byte[] buffer = Encoding.UTF8.GetBytes(s);
// fsWrite.Write(buffer, 0, buffer.Length);
//}
//Console.WriteLine("OK");
//Console.ReadKey();
//虚方法和抽象类
//老师可以起立，学生也可以起立,校长也可以起立
//Person p = new Student();
//p.StanUp();
//Console.ReadKey();
}
}
public abstract class Person
{
public abstract void StanUp();
}
public class Student : Person
{
public override void StanUp()
{
Console.WriteLine("学生起立，说老师好");
}
}
public class Teachar : Person
{
public override void StanUp()
{
Console.WriteLine("老师起立说校长好");
}
}
public class HeadMaster : Person
{
public override void StanUp()
{
Console.WriteLine("请坐");
}
}}
Nuevo contenido para el decimotercer día
1. Modificadores de acceso en C #
público: público, público
privado: privado, solo accesible dentro de la clase actual
protected: protected, solo dentro de la clase actual y la clase El acceso
interno en la subclase de : solo se puede acceder en el ensamblado actual y tiene los mismos permisos que el público en el mismo proyecto.
protegido interno: agregue los permisos de protegido e interno
1. Los únicos modificadores de acceso que pueden modificar la clase son públicos e internos
. 2. La accesibilidad de la
subclase no puede ser mayor que la de la clase principal, de lo contrario los miembros de la clase principal quedarán expuestos
2. Patrón de diseño (una forma de diseñar este proyecto)
Patrón de diseño de fábrica simple
namespace _03简单工厂设计模式
{
class Program
{
static void Main(string[] args)
{
Console.WriteLine("请输入你需要的笔记本品牌");
string note = Console.ReadLine();
NoteBook nb = GetNoteBook(note);
nb.SayHello();
Console.ReadKey();
}
/// <summary>
/// 简单工厂的核心，根据用户输入的对象来赋值给父类
/// </summary>
/// <param name="note"></param>
/// <returns></returns>
public static NoteBook GetNoteBook(string note)
{
NoteBook nb = null;
switch (note)
{
case "Lenove" : nb = new Lenovo();
break;
case "Acre" : nb = new Acre();
break;
case "Dell" : nb = new Dell();
break;
case "Hp" : nb = new Hp();
break;
}
return nb;
}
}
public abstract class NoteBook
{
public abstract void SayHello();
}
public class Lenovo : NoteBook
{
public override void SayHello()
{
Console.WriteLine("我是联想笔记本，你连想都别想");
}
}
public class Acre : NoteBook
{
public override void SayHello()
{
Console.WriteLine("我是宏碁笔记本");
}
}
public class Dell : NoteBook
{
public override void SayHello()
{
Console.WriteLine("我是戴尔笔记本");
}
}
public class Hp : NoteBook
{
public override void SayHello()
{
Console.WriteLine("我是惠普笔记本");
}
}
}En tercer lugar, la transferencia de tipos de valor y tipos de referencia Cuando
se copia el tipo de valor, es el valor en sí mismo. Cuando
se copia el tipo de referencia, se pasa la referencia a este objeto.
4. Serialización y deserialización Serialización
: convertir el objeto a binario
Deserialización: convertir binario a objeto
Función: Transferir
serialización de datos :
1. Marque esta clase como serializable y agregue una clave a la clase Palabra: [serializable]
gramática
namespace _04序列化和反序列化
{
class Program
{
static void Main(string[] args)
{
////序列化
//Person p = new Person();
//p.Name = "张三";
//p.Age = 18;
//p.Gender = '男';
//using (FileStream fsWrite = new FileStream(@"C:\Users\Administrator\Desktop\111.txt", FileMode.OpenOrCreate, FileAccess.Write))
//{
// //开始序列化对象
// BinaryFormatter bf = new BinaryFormatter();
// bf.Serialize(fsWrite, p);
//}
//Console.WriteLine("写入成功");
//Console.ReadKey();
//接收对方发送过来的二进制 反序列化成对象
Person p;
using (FileStream fsRead = new FileStream(@"C:\Users\Administrator\Desktop\111.txt", FileMode.OpenOrCreate, FileAccess.Read))
{
BinaryFormatter bf = new BinaryFormatter();
p = (Person)bf.Deserialize(fsRead);
}
Console.WriteLine(p.Name);
Console.WriteLine(p.Age);
Console.WriteLine(p.Gender);
Console.ReadKey();
}
}
[Serializable]
public class Person
{
private string _name;
public string Name
{
get { return _name; }
set { _name = value; }
}
private int _age;
public int Age
{
get { return _age; }
set { _age = value; }
}
private char _gender;
public char Gender
{
get { return _gender; }
set { _gender = value; }
}
}
}Cinco, algunas clases
están escritas con el mismo nombre en el mismo espacio de nombres, la palabra clave: parcial se
usa principalmente para el desarrollo de varias personas, debe escribir una
sintaxis de clase
Persona pública de clase parcial
Seis, las clases selladas
no se pueden heredar, pero las clases selladas pueden heredar otra
sintaxis de clase
pública clase sellada Persona
Siete, reescribe el método ToString,
todas las cosas pueden ser ToString, debería ser ToString es un método de Object, todos los objetos son
sintaxis de subclase de Object
namespace _05重写ToString方法
{
class Program
{
static void Main(string[] args)
{
Person p = new Person();
Console.WriteLine(p.ToString());
Console.ReadKey();
}
}
public class Person
{
public override string ToString()
{
return "Hello word";
}
}
}8. Interfaz (la interfaz es una especificación, capacidad)
sintaxis
[pública] interfaz I ... able
{
// Los miembros de la interfaz no pueden agregar modificadores de acceso, el valor predeterminado es público
// En la interfaz, las funciones con cuerpos de métodos no están permitidas , No se pueden incluir campos
// En la interfaz, puede escribir atributos automáticos (no escritos, pero se generarán automáticamente al compilar)
public int Age
{
get;
set;
}
Members ...
}
Los miembros de la interfaz son: métodos, atributos automáticos e indexadores, sin embargo: los atributos automáticos son esencialmente dos funciones y los indexadores también son funciones. Entonces: los miembros de la interfaz tienen: métodos
Las características de la
interfaz : una interfaz es una especificación, siempre que una clase herede una interfaz, la clase debe implementar todos los miembros de la interfaz.
public class Person : IFyable
{
//实现这个接口中所有的成员
public void Fly()
{
Console.WriteLine("飞");
}
}
public interface IFyable
{
void Fly();
}Para el polimorfismo, no se puede crear una instancia de la interfaz. En otras palabras, la interfaz no puede ser nueva (no se pueden crear objetos)
static void Main(string[] args)
{
//接口是不能被实例化的，因为接口中的成员没有方法体
// IFyable fly = new IFyable();
//如果要想实现多态，则需要指向一个对象
IFyable fly = new Person();
fly.Fly();
Console.ReadKey();
}No se pueden agregar "modificadores de acceso" a los miembros de la interfaz. Los modificadores de acceso de miembros en la interfaz son públicos por defecto y no se pueden modificar. Los miembros de la interfaz no pueden tener ninguna implementación ("solo hablar sin práctica", solo definir un grupo de miembros no implementados. Similar a las funciones abstractas en clases abstractas)
Solo puede haber métodos, propiedades automáticas, indexadores y eventos en la interfaz, no "campos" ni constructores.
La interfaz y la interfaz pueden heredar y pueden heredar múltiples
public interface M1
{
void Test1();
}
public interface M2
{
void Test2();
}
public interface M3
{
void Test3();
}
public interface M4:M1,M2,M3
{
}
public class Cat : M4
{
public void Test1()
{
throw new NotImplementedException();
}
public void Test2()
{
throw new NotImplementedException();
}
public void Test3()
{
throw new NotImplementedException();
}
}Una interfaz no puede heredar una clase y una clase puede heredar una interfaz (una interfaz solo puede heredar de una interfaz y una clase puede heredar una interfaz o una clase) para
implementar subclases de la interfaz, todos los miembros de la interfaz deben implementarse.
Una clase puede simultáneamente Heredar una clase e implementar múltiples interfaces, si una subclase también hereda la clase padre A. E implementar la interfaz de interfaz IA, luego la sintaxis A debe escribirse delante de la
sintaxis IA :
clase pública B: A, IA
{
miembro de clase
}
Dado que este conjunto de videos en toda la red tiene problemas con la interfaz, lo dejo para la revisión.
namespace _06接口
{
class Program
{
static void Main(string[] args)
{
//接口是不能被实例化的，因为接口中的成员没有方法体
// IFyable fly = new IFyable();
//如果要想实现多态，则需要指向一个对象
IFyable fly = new Person();
fly.Fly();
Console.ReadKey();
}
}
public class Person : IFyable
{
//实现这个接口中所有的成员
public void Fly()
{
Console.WriteLine("飞");
}
}
public interface IFyable
{
void Fly();
}
public interface M1
{
void Test1();
}
public interface M2
{
void Test2();
}
public interface M3
{
void Test3();
}
public interface M4:M1,M2,M3
{
}
public class Cat : M4
{
public void Test1()
{
throw new NotImplementedException();
}
public void Test2()
{
throw new NotImplementedException();
}
public void Test3()
{
throw new NotImplementedException();
}
}
}Nueve, muestra la
gramática y el uso de la interfaz de implementación (para resolver el problema de los nombres duplicados de los métodos)
namespace _07显示实现接口
{
class Program
{
static void Main(string[] args)
{
IFlyable fly = new bird();
fly.Fly();
bird bi = new bird();
bi.Fly();
Console.ReadKey();
}
}
public class bird:IFlyable
{
public void Fly()
{
Console.WriteLine("鸟会飞");
}
/// <summary>
/// 显示实现接口
/// </summary>
void IFlyable.Fly()
{
Console.WriteLine("我是接口的飞");
}
}
public interface IFlyable
{
void Fly();
}
}Resumen:
1. Cuándo usar métodos virtuales para lograr polimorfismo.
En la clase provista, se puede abstraer una clase principal. La clase principal debe escribir los métodos compartidos por las subclases, saber cómo escribir este método y también debe crear la clase principal Objeto, luego usa métodos virtuales
2. Cuándo usar clases abstractas para lograr polimorfismo.
En las clases proporcionadas, una clase principal se puede abstraer. La clase principal debe escribir los métodos compartidos por las subclases, y no sabe cómo escribir este método, luego use la clase abstracta
3. Cuándo usar interfaces para implementar polimorfismo
. Entre varias clases, no se puede encontrar la clase principal, pero todas tienen un comportamiento común, así que use la interfaz de inmediato.
Ejercicio de interfaz
namespace _08接口练习
{
class Program
{
static void Main(string[] args)
{
//真的鸭子会游泳，木头鸭子不会游泳，橡皮鸭子会游泳
ISwimming swim = new RealDuck();
swim.Swim();
Console.ReadKey();
}
}
public class RealDuck : ISwimming
{
public void Swim()
{
Console.WriteLine("真的鸭子会游泳");
}
}
public class MuDuck
{
}
public class XPDuck : ISwimming
{
public void Swim()
{
Console.WriteLine("橡皮鸭子漂着游泳");
}
}
public interface ISwimming
{
void Swim();
}
}Combate real completo: sistema de caja de supermercado
Analizar los requisitos del sistema
. Productos proporcionados por los supermercados: computadoras portátiles, teléfonos móviles, salsa de soja y bananas. Los
productos en el supermercado deben tener: precio, cantidad, número.
Esto puede abstraer una categoría principal (ProductFather), incluido el precio (Price) y la cantidad (Count) , Número (ID)
Si las cosas no son suficientes para vender, debe ir al almacén para obtener
las funciones que necesita el almacén: almacenar mercancías, recoger y comprar
Cuando los supermercados venden cosas, necesitan una función de caja registradora
Resumen de la categoría principal de una mercancía
class ProductFather
{
public decimal Price
{
get;
set;
}
public double Count
{
get;
set;
}
public string ID
{
get;
set;
}
public ProductFather(string id, decimal price, double count)
{
this.ID = id;
this.Price = price;
this.Count = count;
}
}Cree clases de productos por separado y herede de la clase principal
class ShouJi:ProductFather
{
public ShouJi(string id, decimal price, double count) : base(id, price, count)
{
}
}Crear una clase de almacén
class CangKu
{
// 1. Almacenar mercancías
//1.1 lista equivale a un almacén, y List <ProductFather> agrega una colección de datos, que equivale a colocar estantes en un almacén, para clasificar
List <List <ProductFather>> list = new List <List < ProductFather >> ();
/// <summary>
/// 想用户展示货物
/// </summary>
public void ShowPros()
{
foreach (var item in list)
{
Console.WriteLine("仓库有：" + item[0].Name + "," + "\t" + "有" + item.Count + "个，" + "\t" + "每个" + item[0].Price + "元。");
}
}
/// <summary>
/// 创建仓库对象时，向仓库中添加货架
/// </summary>
//list[0] 存电脑 list[1]存手机 list[2]存酱油 list[3]存香蕉，这时候如果多，就能通过循环来完成
public CangKu()
{
list.Add(new List<ProductFather>());
list.Add(new List<ProductFather>());
list.Add(new List<ProductFather>());
list.Add(new List<ProductFather>());
}
/// <summary>
/// 进货
/// </summary>
/// <param name="strType">货物的类型</param>
/// <param name="count">货物的数量</param>
public void GetPros(string strType,int count)
{
for (int i = 0; i < count; i++)
{
switch (strType)
{
case "NoteBook": list[0].Add(new NoteBook(Guid.NewGuid().ToString(), 5000, "笔记本电脑"));
break;
case "ShouJi":list[1].Add(new ShouJi(Guid.NewGuid().ToString(), 3000, "手机"));
break;
case "JiangYou":list[2].Add(new JiangYou(Guid.NewGuid().ToString(), 10, "酱油"));
break;
case "Banana":list[3].Add(new Banana(Guid.NewGuid().ToString(), 20, "香蕉"));
break;
}
}
}
/// <summary>
/// 取货
/// </summary>
/// <param name="strType">货物的类型</param>
/// <param name="count">货物的数量</param>
//货物取出后，需要放哪？而且有可能会拿很多个所以返回ProductFather[]
public ProductFather[] QuPros(string strType, int count)
{
ProductFather[] pros = new ProductFather[count];
for (int i = 0; i < count; i++)
{
switch (strType)
{
case "NoteBook":
if (list[0].Count == 0)
{
Console.WriteLine("没有电脑了！");
}
else
{
pros[i] = list[0][0];
list[0].RemoveAt(0);
}
break;
case "ShouJi":
if (list[1].Count == 0)
{
Console.WriteLine("没有手机了！");
}
else
{
pros[i] = list[1][0];
list[1].RemoveAt(0);
}
break;
case "JiangYou":
if (list[2].Count == 0)
{
Console.WriteLine("没有酱油了！");
}
else
{
pros[i] = list[2][0];
list[2].RemoveAt(0);
}
break;
case "Banana":
if (list[3].Count == 0)
{
Console.WriteLine("没有酱油了！");
}
else
{
pros[i] = list[3][0];
list[3].RemoveAt(0);
}
break;
}
}
return pros;
}
}