C#编程入门与应用Day9

1.C#中构造函数和类名相同时（构造函数没有返回类型） https://bbs.csdn.net/topics/390084633
2.如何在一个类中调用另一个类中的变量，方法
（1）如果两个类没有继承关系，存取另一个类中变量的方法如下：
请特别注意“类变量”和“实例变量”的差异！（2）如果两个类有继承关系，存取基类中变量的方法如下3.单个字符叠加利用循环的方法using System;
namespace test1
{
enum Color { White,Black,Yellow,Other}
class Dog
{
int faceNumber;
int shoutNumber;
readonly Color dogColor = Color.White;
readonly double dogPrice = 500;
string dogName;
public Dog(string dogName)
{
DogName = dogName;
}
public int FaceNumber
{
get { return faceNumber; }
set { faceNumber = value; }
}
public string DogName
{
get { return dogName; }
set { dogName = value;}
}
public int ShoutNumber
{
get { return shoutNumber; }
set { shoutNumber = value;}
}
public Color DogColor
{
get { return dogColor; }
}
public double DogPrice
{
get { return dogPrice;}
} public void Shout()
{
int i = 0;
string ShoutNum = "";
do
{
ShoutNum += "汪！";
i++;
}
while (i<=shoutNumber);
Console.WriteLine(ShoutNum);
}
}
class Test
{
static void Main(string[] args)
{
Dog dog = new Dog("小黑");
while(true)
{
dog.FaceNumber = Convert.ToInt32(Console.ReadLine());
if (dog.FaceNumber < 5)
{
dog.ShoutNumber = 5;
}
else
{
dog.ShoutNumber = 2;
}
dog.Shout();
}
}
}
}

创建枚举类型后，可以在之后的程序中创建枚举数据类型，其值为枚举类型中的成员。
enum Color{...}
...
public Color Dogcolor
4.Object类 http://blog.csdn.net/qq_30122639/article/details/53610421
Object类型数据 http://blog.csdn.net/sangjisuonan/article/details/59047759
5.using System;

namespace test1
{
public abstract class Shape
{
private string name;
public Shape(string name)
{
this.name = name;
}
public string Name
{
get { return name; }
set { name = value; }
}
public abstract double Area { get; }
public override string ToString()
{
return name + "Area=" + string.Format("{0:F2}", Area);
}
}
public class Square : Shape
{
private int side;
public Square(int side,string name) : base(name)
{
this.side = side;
}
public override double Area
{
get
{
return side * side;
}
}
}
public class program
{
static void Main(string[] args)
{
Square shape = new Square(5,"边长为5的正方形");
Console.WriteLine(shape);//为什么可以打印出：边长为5的正方形 Area=25.00？？
Console.ReadKey();
}
}
}

6.double result = 0d;//0d表示double类型的0,0f表示float类型的07.using System;

namespace test1
{
class Operation1
{
private double numberA = 0;
private double numberB = 0;
public double NumberA
{
get { return numberA; }
set { numberA = value; }
}
public double NumberB
{
get { return numberB; }
set { numberB = value; }
}
public virtual double GetResult()
{
double result = 0;
return result;
}
}
class OperationAdd :Operation1
{
public override double GetResult()
{
double result = NumberA + NumberB;
return result;
}
}
class OperationDiv : Operation1
{
public override double GetResult()
{
double result = 0;
if (NumberB != 0)
result = NumberA / NumberB;
else
{
Console.WriteLine("除数不能为0");
}
return result;
}
}
class OperationFactory
{
public static Operation1 creatOperation(string operate)
{
Operation1 oper = null;//这个和下面的代码组成Operation1 oper=new OperationAdd(）;?? switch (operate）

{
case "+": oper = new OperationAdd();
break;
case "/": oper = new OperationDiv();
break;
}
return oper;
}
}
class Program { static void Main(string[] args)
{
Console.WriteLine("请输入数字A");
string numberA = Console.ReadLine();
Console.WriteLine("请输入计算字符“+，/”");
string op=Console.ReadLine();
Console.WriteLine("请输入数字B");
string numberB=Console.ReadLine();
Operation1 oper = new Operation1();
oper=OperationFactory.creatOperation(op);//先进行实例化再给父类中的NumberA和NumberB赋值

oper.NumberA=Convert.ToDouble(numberA);

oper.NumberB =Convert.ToDouble(numberB);
double result = oper.GetResult();
Console.WriteLine(result); Console.ReadKey();
}
}
}

8.程序设计有六大准则，23中模式。 http://www.360doc.com/content/15/1205/15/29321654_518096459.shtml
9.程序的耦合性：
程序的耦合度是 你的子程序之间的相关联性,也就是说你的多个类的联系 是否太紧密，打个比方，你房子里边有窗子 ，那房子 和窗子 就有了关联
耦合度 是松还是紧 就看你的 关联 是强还是弱，也就是修改的代价，比如 你窗子是扣死在墙里的 那么你修改窗子 就必须修改墙 这就比较紧密了，但是如果你窗子是按照某种规格的 可以自由拆装的 那么修改的代价就小，耦合度也就低了
我们写程序的目标就是 高内聚 低耦合！
这样修改起来 就不会有太多的联系 不用 改一个地方 其他的都要修改10.基类的引用
派生类的对象包含基类和派生类部分，所以我们可以通过一个基类类型的引用指向派生类，通过指向派生类的基类的引用，我们仅仅能访问派生类中的基类部分。using System;

namespace test1
{
class Pet
{
public string Name;
public void PrintName()
{
Console.WriteLine("宠物的名字是：" + Name);
}
}
class Dog :Pet
{

}
class Program
{
public static void Main(string[] args)
{
Dog dog = new Dog();

//可以通过基类的类型引用指向派生类即 Pet dog =new dog 效果相同。这里基类和派生类中的PrintName（）相同。
dog.Name = "小黑";
dog.PrintName();
Console.ReadKey();
}
}
}

若派生类隐藏了基类中的方法，则通过基类的类型引用指向派生类对象，所调用的方法不同。using System;

namespace test1
{
class Pet
{
public string Name;
public void PrintName()
{
Console.WriteLine("宠物的名字是：" + Name);
}
}
class Dog :Pet
{
new public void PrintName()//这是定义与父类函数签名相同的方法，这个方法屏蔽了父类中同签名的方法
{
Console.WriteLine("the pet's name is:" + Name);
}

}
class Program
{
public static void Main(string[] args)
{
/* Dog dog = new Dog();
dog.Name = "小黑";
dog.PrintName();//这里调用的方法是派生类中Console.WriteLine("The pet's name is ："+Name)
Console.ReadKey();*/

 Pet dog = new Dog();
dog.Name = "小黑";
dog.PrintName();//这里调用的方法是基类中Console.WriteLine("宠物的名字是："+Name)
Console.ReadKey();

} }}如果在基类中创建Virtual方法，然后在派生类中重写Virtual方法，则引用基类类型指向派生类时，通过派生类调用方法，则调用的是派生类中重写的方法。using System;

namespace test1
{
public class Pet
{
public string Name;
public Pet(string name)//构造函数，主函数中简化了Pet.Name的定义
{
Name = name;
}
public virtual void Speak()
{
Console.WriteLine("The pet is speaking");
}
}
public class Dog : Pet
{
string PetName;
public Dog(string Name) : base(Name)
{
PetName = Name;
}
override public void Speak()
{
Console.WriteLine(Name+"汪汪汪");
}
}
class Program
{
public static void Main(string[] args)
{
Pet dog = new Dog("小黑");//同样是引用基类指向派生类对象
dog.Speak();//这里调用的方法是派生类中的Console.WriteLine(Name+"汪汪汪")
Console.ReadKey();
}
}
}

利用数组将所有派生类集合在一起：using System;

namespace test1
{
public class Pet
{
public string Name;
public Pet(string name)
{
Name = name;
}
public virtual void Speak()
{
Console.WriteLine("The pet is speaking");
}
}
public class Dog : Pet
{
string PetName;
public Dog(string Name) : base(Name)//基类中初始化PetName，基类中的PetName最好在基类中初始化，初始化即赋值
{
PetName = Name;
}
override public void Speak()
{
Console.WriteLine(Name+"汪汪汪");
}
}
public class Cat : Pet
{
string PetName;
public Cat(string Name) : base(Name)
{
PetName = Name;
}
override public void Speak()
{
Console.WriteLine(Name + "喵喵喵");
}
}
class Program
{
public static void Main(string[] args)
{
Pet[] pets = new Pet[] { new Dog("小狗"), new Cat("小猫") };//创建数组
/* for(int i = 0; i< pets.Length; ++i)//for循环
{
pets[i].Speak();
} */

foreach( Pet pet in pets)//foreach循环   Pet是数据类型，pet是创建变量名读取集合中每一个元素
            {
                pet.Speak();
            }

 Console.ReadKey();
}
}
}

11.关于构造函数
构造函数 是一种特殊的方法 主要用来在创建对象时初始化对象 即为对象成员变量赋初始值
总与new运算符一起使用在创建对象的语句中 特别的一个类可以有多个构造函数 可根据其参数个数的不同或参数类型的不同来区分它们 即构造函数的重载https://www.cnblogs.com/xiaz/p/4613722.html 
 派生类对象中，有一部分是基类部分，在执行派生类的构造函数体之前，将会隐式或者显式调用基类的构造函数。class MyDerived:MyBase
{
/* MyDerived(){}//隐式使用基类构造函数*/
MyDerived()：base（）{}//显式使用基类构造函数
}还可以用this调用当前类的构造函数Pet(int age,string name):this(name)//调用公共初始化的函数
{......}
Pet(string name)//构造函数的重载
{......}
调用顺序：实例成员初始化-基类构造函数初始化-派生类构造函数class MyDerived:MyBase
{
int field=5;//首先实例成员初始化
MyDerived(){}...//最后派生类构造函数初始化
}
class MyBase
{
MyBase{};...//其次基类构造函数初始化
}调用基类中的构造函数初始化Nameusing System;

namespace test1
{
public class Pet
{
public string _name;//重命名变量，也叫重构，一般下划线_表示私有
public Pet(string name)
{
_name = name;
}
public virtual void Speak()
{
Console.WriteLine("The pet is speaking");
}
}
public class Dog : Pet
{
public Dog(string Name) : base(Name)//这里的参数可以为Name而不和_Name相同，其作用为调用改造函数，初始化参数
{

}
override public void Speak()
{
Console.WriteLine(_name+"汪汪汪");
}
}
public class Cat : Pet
{
public Cat(string Name) : base(Name)//调用基类中的构造函数初始化Name，更加简洁
{

}
override public void Speak()
{
Console.WriteLine(_name + "喵喵喵");
}
}
class Program
{
public static void Main(string[] args)
{
Pet[] pets = new Pet[] { new Dog("小狗"), new Cat("小猫") };
foreach( Pet pet in pets)//foreach循环 Pet是数据类型，pet是创建变量名读取集合中每一个元素
{
pet.Speak();
}
Console.ReadKey();
}
}
}