A4第四章第2节null和成员变量、局部变量的不同初始化

A4第四章第2节null和成员变量、局部变量的不同初始化第4节 1、null表示变量没有指向任何对象 如：Person p=null; p.sayHello();//结果会抛出异常 2、对于一个为【null的变量】调用【成员方法】都会报异常NullReferenceException。

3、值类型(ValueType)：数值类型(int、long、double等）、boolean等基本类型，枚举、结构体。不能为null。String不是值类型。

public void setAge(int age)

{

this.age = age;

}

1、局部变量【必须初始化】，成员变量声明时【默认初始化】，基本数值类型【默认初始值为int】，String等非基本类型【初始化为null】。why?涉及到栈内存和堆内存，以后讲。

A4第四章第2节定义类字段方法及实例化类

第四章第2节 1、字段不加public，定义的方法加public 2、方法一般是大写开头

3、最简单的类：class Person{}

4、增加类变量（字段）（成员变量）和方法：

class Person{ private int age;//成员变量 private String name; public void setAge(int age1)//定义的方法setAge方法，age1为传入的变量 { this.age = age1; } public void setName(String name1)//定义setName方法，name1为传入的变量 { this.name = name1; } public void sayHello()//定义sayHello方法 { Console.WriteLine("大家好，我是"+name+"，我今年"+age+"岁了"); } //再提供get方法 }

5、类的实例化： Person lzy = new Person();// lzy.setName("林志颖"); lzy.setAge(80); lzy.sayHello(); //两个对象的内存分配：根据模板拷贝两份。 yzk.sayHello(); new出的每个对象都是一个单独的实例，两个对象之间的成员变量是独立的两份。new出来的叫【类对象】或者【实例(Instance)】。 6、我们定义一个【类】后，就必须实例化才能使用。【实例化】就是创建一个【对象】的过程。 在C#中，我们使用new运算符关键字来创建。 7、 类 对象=new 类(); 即 class object=new class(); 即Person xcl=new Person(); 8、比如有一个类叫汽车。你现在想在程序中买一辆，所以你用new来买了一辆汽车，这辆车你得给它找个名字， 比如宝马。 例如：汽车 宝马 = new 汽车(); 你有钱了，你要再来一辆： 汽车 奔驰 = new 汽车();

A4第四章第5节this解决成员变量和局部变量重名的问题

第四章第5节 1、当成员变量和局部变量（函数参数也可以看做局部变量）重名的时候，被看做局部变量，因此为了避免混乱，建议访问成员变量的时候加上“this.”，this代表当前对象。

2、new Person().sayHello();创建一个匿名对象，然后调用。输出结果是？ new Person().sayHello(); 等价于 Person t=new Person(); t.sayHello(); 3、【类】里边定义的变量是成员变量，【方法】里边定义变量叫做局部变量

A4第四章第6节public和private

第四章第6节 1、我们可以把age成员变量声明为public，也可以把setAge声明为private，这样就只能在【类内部】调用private成员（再写一个方法调用private的setAge）

2、结论：public成员可以【被类内部或者外部】访问，private成员【只能被类内部】访问。这样可以保护不希望外接调用的内部成员(Member，包含字段Field/变量、方法)不被外界访问。

3、直接通过public的age设置年龄，不通过setAge赋值，这样有什么坏处？-1。【不能有效控制非法字符的赋值】

4、字段(Field)/成员变量(Member Variable)一般声明为private。通过get/set方法来进行取值/赋值。

A4第四章第7节属性入门

第四章第7节 1、为了避免外界给成员变量随便赋值，必须把成员变量声明为private，然后提供get/set方法，写起来、调用起来都麻烦，C#提供了“属性”这样一个语法：

private int height;//成员变量 public int Height//写成大写格式，方便外界调用属性值//如果改为private则只能在内部调用 { get { return this.height; } set { this.height = value; } } p.Height=50;//相当于调用【set方法对p的Height进行【赋值】 int a = p.Height;//相当于调用【get方法对p的Height进行【取值】

通过Reflector看属性本质上是什么？（ ILSpy的C#看的优化后的代码，IL看的是IL代码，看不懂 ）

public void set_Height(int value)//反编译中查看的代码set { this.height = value; } public int get_Height()//反编译中查看的代码get { return this.height; }

A4第四章第8节 属性的简化写法

第四章第8节 1、//如果是简单地set。get逻辑，暂时没有更多的逻辑代代码，可以简化如下； public string Name { get; set; } 2、Reflector反编译器 查看PropertyTest1.exe--{}propertyTest1-Name:string 发现显示的语法其实还是以前讲的定义的 public void getAge(int Age) { return this.Age; } public void setAge(int Age) { this.Age=Age; }

1、如果是简单set/get逻辑，可以使用更简写的语法： public int Weight { get; set; } 通过Reflector看本质是什么

2、get、set可以有一个声明为private、protected，这样就可以设置不同的访问级别。

3、如果只有get或者set就是只读或只写属性。只读只写【不能简化写】。

A4第四章第9节 构造函数入门和属性赋值的简化写法

第四章第9节 1、构造函数是创建类对象，并且在创建完成前对类进行初始化的特殊函数。如果定义类时没有声明构造函数，【默认】会给出一个无参构造函数，如果定义了任意一个构造函数，将【不会】提供默认的无参构造函数。

2、构造方法/函数格式及特点：

方法名【必须】和类名一致

【没有】返回值类型

构造函数可以重载，Person(String name,int age)

3、 class Person { public int Id { get; set; }//id属性 public string Name { get; set; }//Name属性 public int Age { get; set; }//Age属性 public Person()//默认的构造函数【也可以不写，但是通过反编译器会看到它是默认存在的】 { } public Person(int id)//构造id函数，给id进行初始化、、它的存在会使默认的构造函数失去。除非。你申明了默认构造函数 { this.Id = id; } } Person p = new Person() { Id=5,Name="abc"};//new出来一个新的对象，并且赋值id和Name Person p1 = new Person(5) { Name = "aaa", Age = 12};//Person后的括号中的5其实是初始化年龄为5，花括号内的Age又重新对new出的对象赋值了12 Person p2 = new Person { Id=5,Name="a"};//Person后的括号可以省去，但是最好不要省去

通过ILSpy反编译看一下，还是一个编译器玩的“语法糖”，所以和构造函数不一样，赋值是在对象构造之后

A4第四章第10节static介绍

第四章第10节 1、一些场景下会要求一个类的多个实例共享一个成员变量；有时候想定义一些不和具体对象关联、不需要new就调用的方法

举例：Console类的WriteLine，MessageBox的Show

2、static方法不需要new就可以直接通过类名调用。

3、static变量不需要new就可以直接通过类名调用。static变量是共享的内存空间，非static变量则是对象隔离的。

4、static 方法中无法使用this关键字，因为static独立于对象存在，不是任何人的唯一。

5、static成员中只能访问static成员，不能直接访问非static成员。非static成员可以访问static成员。

A4第四章第11节单例模式

第四章第11节 1、有的类在系统中只能有一个对象（*，资源管理器、缓存管理器等），这时就要使用“单例模式”（singleton）。实现单例模式有很多方法，先介绍最简单、最实用的“饿汉式”。

2、单例模式的实现步骤：

1）构造函数声明为private，这样避免外界访问

2）定义一个private readonly static的对象实例，static成员的初始化只在类第一次使用的时候执行一次。readonly修饰变量只能在构造函数或者初始化的时候赋值。

3）定义一个public static的getInstance方法，返回唯一实例。

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace SingletonTest1 { class God { //静态变量的初始化只执行一次 private static God Instance = new God(); private God() { }//构造函数声明为private，避免外界调用 public void ZhaoYaoDaDi() { Console.WriteLine("照耀"); } public static God GetInstance() { return Instance; } } }

A4第四章第12节静态代码块以及面试题

第四章第12节 class MyTest { static MyTest() { Console.WriteLine("zi 静态代码块"); } public MyTest() { Console.WriteLine("zi 构造方法"); } } MyTest t1 = new MyTest(); MyTest t2 = new MyTest(); 【静态代码块在类第一次被使用的时候执行一次，在构造函数执行之前执行。【只要用到类】，哪怕没new对象（比如只是声明变量）也会被执行，且只执行一次。

public class MyJingTaiDaimaKuai { public static int i = test1();//最开始执行 public int age = test2();//new的时候先执行成员变量的初始化，再执行构造函数 static MyJingTaiDaimaKuai() { Console.WriteLine("静态代码块");//再执行 } public MyJingTaiDaimaKuai() { Console.WriteLine("构造函数"); } public static int test1() { Console.WriteLine("test1"); return 3; } public static int test2() { Console.WriteLine("test2"); return 333; } } MyJingTaiDaimaKuai a1 = new MyJingTaiDaimaKuai(); Console.WriteLine(a1.age); MyJingTaiDaimaKuai a2 = new MyJingTaiDaimaKuai(); Console.WriteLine(a2.age);

【一般用于对类进行初始化，以后会用

只要一旦开始“接触一个类”，静态成员、static代码块就会被执行】

A4第四章第13节命名空间

第四章第13节 用文件系统的文件夹解释避免文件名重复的问题。

命名空间语法：

namespace ConsoleApplication1包住类；

当前命名空间中的类无需引用；使用using引用其他包中的类：

还可以直接通过“命名空间+类名”的方式使用“System.Data.SqlClient.SqlConnection”，不用using，适用于同时使用多个重名的类，比using时候的别名好；

A4第四章第14节继承基本语法

第四章第14节 C#中一个类可以“继承”自其他类，如果A继承自B，则A叫做B的子类，B叫做A的父类(基类)。子类会从父类继承所有非private成员。子类还可以有子类。

C#中一个类只能有一个父类，如果没指定父类，则System.Object为父类。

class FuLei { private void method1() { } public void method2() { } } class ZiLei : FuLei { private void method3() { } public void method4() { } } ZiLei zl1 = new ZiLei(); zl1.method1(); zl1.method2(); zl1.method4(); zl1.toString();

A4第四章第15节继承中的构造函数

第四章第15节 C#中一个类可以“继承”自其他类，如果A继承自B，则A叫做B的子类，B叫做A的父类(基类)。子类会从父类继承所有非private成员。子类还可以有子类。

C#中一个类只能有一个父类，如果没指定父类，则System.Object为父类。

子类的构造方法默认都去访问了父类的【无参构造方法】：在子类中的构造方法后都有一行默认语句 base()

class Fu { public Fu() { Console.WriteLine("fu"); } } class Zi : Fu { public Zi() : base()//不管是否显式调用，控制台都会输出fu { Console.WriteLine("zi"); } } Zi z = new Zi(); 先执行父类的构造函数把父类初始化完成，再初始化子类的。

可以通过super(参数)去访问父类中的有参构造函数。可以通过this(参数...)去访问本类中的其他构造函数。

class Fu { public Fu(int a) { Console.WriteLine("fu"+a); } } class Zi : Fu { public Zi():base(0)//为了避免出错，给父类传递一个整数0，来调用父类的有参构造函数 { Console.WriteLine("zi"); } public Zi(int a):base(a)//默认会调用父类的无参的构造函数。不过父类中没有无参构造函数，故将a传递给父类的构造函数 public Fu(int a) { Console.WriteLine("zi"+a); } } 如果定义了构造函数，则类就不会有默认的无参构造函数；如果父类中没有默认的，则子类构造函数必须显示调用父类的构造函数

一个类如果没有定义其他构造函数，则有一个【默认的无参构造函数】。构造函数会默认调用父类的【无参构造函数】 子类的无参或者是有参构造函数都会默认调用父类的【无参构造函数】

A4第四章第16节 private、public和protected的区别

第四章第16节 private成员无法被子类访问，子类只能通过父类的非private方法“间接”访问父类的private成员。这样保证了父类private成员的安全性。

procected成员只能被自己以及子类（直接或者间接）访问，无法被“外姓人”访问。

A4第四章第17节 Override

第四章第17节 面向对象三大特征：封装、继承、多态。多态是面向对象最强大的一个特征，也是最难的一个特征，设计模式等都是多态的体现。大型项目架构也大量应用多态。

子类中定义和父类中一样的方法就叫“重写(Override)或覆盖”，父类中可以被Override方法要声明为virtual 。Override和OverLoad区别见备注

class DiQiuRen { public virtual void speak(){Console.WriteLine("我是地球人");} } class Chinese : DiQiuRen { public override void speak(){Console.WriteLine("我是中国人");} public void baiNian(){Console.WriteLine("过年好！");} } DiQiuRen dqr1 = new DiQiuRen(); dqr1.speak(); Chinese zgr1 = new Chinese(); zgr1.speak();

面试常考： OverLoad：重载，方法的名字一样，参数的类数的个数或者类型不一样。 OverRide：重写，子类有和父类一样（名字，参数个数，类型，返回值）的方法（非private）

A4第四章第18节 多态的精髓

第四章第18节 1、不能用【子类的变量】指向【父类的对象】 例如：Chinese zgr2=new DiQiuRen();//地球人不一定是中国人 2、可以用【父类的变量】指向【子类的对象】 例如：DiQiuRen dqr2=new Chinese();//中国人一定是地球人 3、调用方法还是对象的方法，而不是变量类型的实现 4、记住：：【【能够调用什么方法由变量类型决定，执行谁的方法由实际指向的对象决定】】 DiQiuRen dqr1=new Chinese(); DiQiuRen 是变量类型，，Chinese是指向的对象

下面的执行结果是什么？？ Chinese zgr2=new DiQiuRen();//地球人不一定是中国人 DiQiuRen dqr2=new Chinese();//中国人一定是地球人 dqr2.sayHello();//实际上执行的是Chinese里的sayHello而不是DiQiuRen里的sayHello方法。。执行谁的方法由实际指向的对象决定

5、变量类型是“把对象看成什么”，DiQiuRen dqr2=new Chinese()是把Chinese对象看成是“地球人”，因为“地球人”不一定有baiNian方法，因此dqr2.baiNian()编译失败。

A4第四章第19节 多态与类型转换

第四章第19节 1、编译器只看类型，无法看实际是什么对象 2、ZGR zgr2=(ZGR)dqr2//显示转换..父类显示转换为子类 3、

下面程序的执行结果是什么？

Chinese zgr5 = (Chinese)dqr2;

zgr5.sayHello();

zgr5.baiNian();

Chinese zgr5 = (Chinese)dqr1;

()类型转换可以把“被看做父类对象的实例”重新看成“子类”。(显式类型转换/强制类型转换)

如果对象就是父类对象，当被看成子类对象的时候会失败，抛出运行期异常，编译器无法发现这个错误。

类型转换只能在有父子关系的类中进行

思考：

1、定义一个方法 void test1(DiQiuRen dqr){dqr.sayHello();}

如下调用test1(new Chinese());可以吗？运行结果是什么？

2、String s = (String)zgr1;可以吗？

A4第四章第20节抽象类

第四章第20节 1、把类标记为abstract，这样的类无法被直接实例化（new），这就叫抽象类。

2、DiQiuRen的sayHello输出“我是地球人”显然不合理，因为无法确定怎么说，也就是DiQiuRen不知道如何sayHello， 只有具体到中国人、日本人、美国人才知道如何sayHello

3、把DiQiuRen的sayHello的方法体去掉，并且方法增加abstract修饰，类也修饰为abstract：

abstract class DiQiuRen

{

public abstract void speak();//没有方法体的抽象方法

}

4、抽象方法没有方法体；一旦类中定义了抽象方法，类必须被修饰为抽象；抽象类无法实例化(new)。 5、抽象类中不一定有抽象方法

A4第四章第21节接口

第四章第21节接口 1、接口是一种用来声明“能力”的类型，不提供具体实现

语法：

public interface ISpeakable

{

void speak();

}

2、不提供实现方法，连{}都不能有。

3、接口无法实例化，只能被类“实现”

public class TeacherCang : ISpeakable

{

}

4、既可以使用接口类型变量又可以使用类类型变量调用speak

5、接口的意义是定义“做什么”，类定义“怎么做”

6、接口中不能声明变量（字段），一个没有实现代码的接口中声明变量没意义。

7、接口中可以定义多个方法，也可以不定义任何方法(* 标识接口)。

8、接口只是“能力”不是“实现”，因此不能也没必要定义构造函数。

9、类只能有一个父类，类可以实现多个接口。测试一下：Speakable、Walkable。

************************************************************************************** 接口和抽象类的区别和联系（常见面试题，自己先看看）

1、抽象类里面可以有非抽象方法 但接口里只能有抽象方法 声明方法的存在而不去实现它的类被叫做抽像类（abstract class），它用于要创建一个体现某些基本行为的类，并为该类声明方法，但不能在该类中实现该类的情况。不能创建abstract 类的实例。然而可以创建一个变量，其类型是一个抽像类，并让它指向具体子类的一个实例。不能有抽像构造函数或抽像静态方法。Abstract 类的子类为它们父类中的所有抽像方法提供实现，否则它们也是抽像类为。取而代之，在子类中实现该方法。知道其行为的其它类可以在类中实现这些方法。

2、接口（interface）是抽像类的变体。在接口中，所有方法都是抽像的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽像的，没有一个有程序体。接口只可以定义static final成员变量。接口的实现与子类相似，除了该实现类不能从接口定义中继承行为。当类实现特殊接口时，它定义（即将程序体给予）所有这种接口的方法。然后，它可以在实现了该接口的类的任何对像上调用接口的方法。由于有抽像类，它允许使用接口名作为引用变量的类型。通常的动态联编将生效。引用可以转换到接口类型或从接口类型转换，instanceof 运算符可以用来决定某对象的类是否实现了接口