c#面向对象(二）

方法

声明使用

声明

修饰符 返回值类型 方法名（参数）
{
方法
}

练习

        /// <summary>
        /// 求最大值
        /// </summary>
        /// <param name="a">第一个整数</param>
        /// <param name="b">第二个整数</param>
        /// <returns>最大值</returns>
        public static int GetMax(int a, int b)
        {
            return a>b ? a : b;
        }
        static void Main(string[] args)
        {
            int max=Program.GetMax(2, 3);
            Console.WriteLine(max);
            Console.ReadKey();
        }

方法的参数

类型

1. 值参数：就是不加任何修饰的参数，表示传参时按值传参。

2. ref参数：是形参按引用传递(即便是值类型)，在方法中对形参所做的任何更改都将反应在实参中。

3. out参数：out关键字用来定义输出参数，它会导致参数通过引用来传递，不用进行赋值即可使用

4. params参数：有多个相同类型的参数，可以定义为params参数，是一个一维数组

练习

 private int Add(int x, int y)
        {
            x = x + y;
            return x;
        }
        private int Add(ref int x,int y) {
            x = x + y;
            return x;
        }
        private int Add(int x,int y,out int z)
        {
           z = x + y;
            return z;
        }
        private int Add(params int[] x)
        {
            int result = 0;
            for (int i = 0; i < x.Length; i++)
            {
                result += x[i];
            }
            return result;
        }
        static void Main(string[] args)
        {
            Program program = new Program();
            int x = 20;
            int y = 30;
            int z;
            Console.WriteLine("值类型"+program.Add(x,y));//50
            Console.WriteLine("x的值" + x);//20
            Console.WriteLine("ref参数的值"+program.Add(ref x,y));//50
            Console.WriteLine("ref中x的值" + x);//50
            Console.WriteLine("out参数的值"+program.Add(x,y,out z));//80
            Console.WriteLine("params参数的值" + program.Add(20, 30, 40, 50));//140
            Console.ReadKey();

方法的重载

概念

方法重载指方法名相同，但参数的数据类型，个数或顺序不同的方法。

练习

  public static int Add(int x, int y)
        {
            return x + y;
        }
        public double Add(int x, double y) { 
        return x + y;
        }
        public int Add(int x, int y ,int z) { 
        return x+y + z;
        }
 Program program = new Program();
            int x = 5;
            int y = 7;
            int z = 8;
            double y2 = 5.4;
            Console.WriteLine("第一种重载方式"+x+"+"+y+"="+program.Add(x, y));
            Console.WriteLine("第二种重载方式" + x + "+" + y2+ "=" + program.Add(x, y2));
            Console.WriteLine("第二种重载方式" + x + "+" + y +"+"+z+ "=" + program.Add(x, y2));
            Console.ReadKey();

对象

创建

Program program=new Program();
//Program:类名
//program:创建program对象
//当创建了一个对象后可以使用“对象.类成员”来获取对象的属性和行为。
  public string FullName
        {
            get;
            set;
        }
        public void ShowGoods()
        {
            Console.WriteLine("c#");
            Console.WriteLine(FullName);
        }
  Program program= new Program();
            program.FullName = "nice";
            program.ShowGoods();
            Console.ReadKey();

对象的销毁

//c#拥有一套完整的垃圾回收机制,当一个对象的生命周期结束的时候分配给这个对象的内存地址就会被回收。
//用户不要担心会占用内存，c#的垃圾回收机制会回收那些占用内存的资源
//当然了要知道怎么会被垃圾回收机制当成垃圾
//对象引用超过起作用范围{范围}
//将对象赋为null

类和对象的关系

//类是具有相同或相似结构，操作和约束规则的对象组成的集合
//而对象是某一类具体化实例，每一个类都是具有某些共同特征的对象的抽象

继承

简述概念

//继承的基本思想就是基于某个基类的扩展，而指定的一个新的类。
class a:b{}
//说到继承，基类和衍生出来的类的类成员访问这个问题。
//子类不能访问基类的私有成员，只有public才能访问
//解决这个问题，权限修饰符，protected:只有在本类和子类中访问

练习

 //简单运用
class Goods
        {
            public string TradeCode { get;set; }//属性定义编号
            public string Title { get;set; }//属性定义名称
        }
        class JHC : Goods
        {
            public string jhcj { set; get; }//属性号码
            public void Show() { //方法
                Console.WriteLine("号码:{0},名称：{1}，编号：{2}", jhcj, Title, TradeCode);
            }

        }
        static void Main(string[] args)
        {
            JHC jhc = new JHC();
            jhc.TradeCode = "001";
            jhc.Title = "c#";
            jhc.jhcj = "first";
            jhc.Show();
            Console.ReadKey();
        }

base关键字

简述

//base关键字代表父类，和this类似
//如果重写了父类的方法，就无法调用父类的方法吗？
base.Show();

练习

 class Computer
        {
            public string SayHellow()
            {
                return "c#";
            }
        }
        class Phone:Computer { 
        public string SayHellow()
            {
                return base.SayHellow()+"nice";
            }
        }
 Computer cpr= new Computer();
            Console.WriteLine(cpr.SayHellow());
            Phone PE= new Phone();
            Console.WriteLine(PE.SayHellow());
            Console.ReadKey();

继承中的构造函数和析构函数

多态

简述

//使得派生类的实例可以直接赋予基类的对象，然后直接就可以通过这个对象调用派生类的方法

虚方法重写

//public virtual void Move(){

//}
//public override void Move(){

//}

//练习
///三个交通工具，基类交通工具虚方法move，trval和car重写move并将move方法打印
internal class Program
    {
        static void Main(string[] args)
        {
            Vitel vitel= new Vitel();
            Trval trval= new Trval();
            Car car= new Car();
            Vitel[] virs = { vitel, trval, car };
            vitel.Name = "交通工具";
            trval.Name = "火车";
            car.Name = "小汽车";
            virs[0].Move();
            virs[1].Move();
            virs[2].Move();
            Console.ReadKey();
        }
    }
    class Vitel
    {
        string name;
        public string Name {
            get { return name; }
            set { name = value; }
        }
        public virtual void Move()
        {
            Console.WriteLine("{0}移动方式0",Name);
        }
    }
    class Trval:Vitel {
        public override void Move()
        {
            Console.WriteLine("{0}移动方式1",Name);
        }
    }
    class Car : Vitel
    {
        public override void Move()
        {
            Console.WriteLine("{0}移动方式2", Name);
        }
    }

抽象类和抽象方法

简单理解

//访问修饰符 abstract class 类名：基类或接口
//{类成员}
不与具体的事物相联系，只是表达一种抽象的概念或行为，仅仅是作为其派生类的一个基类。
抽象类和非抽象类的区别
抽象类不能直接实例化
抽象类中可以包含抽象成员，但非抽象类中不可以
抽象类不能密封
//声明抽象方法是需要注意
抽象方法必须声明在抽象类中
声明抽象方法，不能使用virtual,static,private等。

练习

   Title title = new Tao();
            title.Name = "TAOBAO";
            title.Goods = "衣服";
            title.Shop();
            title = new XiQi();
            title.Name = "HONGQISAHNGDIAN";
            title.Goods = "矿泉水";
            title.Shop();
            Console.ReadKey();
  public abstract class Title
    {
        public string Name { get; set; }//商场名称
        public string Goods { get; set; }//商品名称
        public abstract void Shop();
    }
    public class Tao : Title
    {
        public override void Shop()
        {
            Console.WriteLine(Name + "购买 " + Goods);
        }
    }
    public class XiQi : Title
    {
        public override void Shop()
        {
            Console.WriteLine(Name + "购买 " + Goods);
        }
    }

接口的使用

简述

//通过接口实现多重继承的功能
//声明方式
修饰符 interface 接口名称：继承的接口列表
{
接口内容
}
//特征
接口类似于抽象类，继承接口的任何类型都必须实现接口的所有成员
接口中不能包含构造函数，因此不能直接实例化接口
接口可以包含属性，方法，索引器和事件
接口中只能定义成员，不能实现成员
接口中定义的成员不允许加访问修饰符，因为接口成员永远是公共的
接口成员不能声明为虚拟或静态

练习

 Iperson[] person=new Iperson[] { new Student(), new Teacher()};
            person[0].Name = "perter";
            person[0].Age = 18;
            person[1].Name = "teacher";
            person[1].Age = 40;
            person[0].work();
            person[1].work();
            person[1].speek();
            person[0].speek();
            Console.ReadKey();
interface Iperson//接口
    {
        string Name { get; set; }//名字属性
        int Age { get; set; }//年龄属性
        void work();//工作方法
        void speek();//说话方法
    }
    class Student : Iperson
    {
        public string Name { get; set; }//
        private int age { get; set; }
        public int Age
        {
            get { return age; }
            set {
                if (age > 0 && age < 120)
                {
                    age = value;
                }
            }
        }
        public void work()
        {
            Console.WriteLine(Name + "老师好");
        }
        public void speek()
        {
            Console.WriteLine(Name+"老师知道了，正在记笔记");
        }
    }
    class Teacher : Iperson
    {
        public string Name { get; set; }
        private int age { get; set; }
        public int Age
        {
            get { return age; }
            set
            {
                if(age > 0 &&age < 120)
                {
                    age= value;
                }
            }
        }
        public void work()
        {
            Console.WriteLine(Name + "开始上课");
        }
        public void speek()
        {
            Console.WriteLine(Name + "同学们记笔记");
        }
    }