黑马程序员——02 面向对象基础

最新推荐文章于 2021-12-30 22:24:14 发布
最新推荐文章于 2021-12-30 22:24:14 发布
阅读量586 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wentaonpa/article/details/9238959
版权

------- Windows Phone 7手机开发、.Net培训、期待与您交流！ -------

（面向对象不是取代面向过程的）

——类，对象

 类：类是抽象的，不占内存

规则：人，碗，车，等都属于类

例码：

1.创建一个”人”类

classPerson//创建一个“人”类
{
    publicint Height;//人类中的身高字段
    publicint Age;//人类中的年龄字段
    publicstring Name;//人类中的姓名字段
 
    publicvoid SayHello()//人类中的方法：SayHello
        {
            Console.WriteLine("HELLO");
        }
    }

对象：是具体的，占内存

规则：张三，陶瓷碗，牌照为8888的奥迪车等都属于类中的对象

例码：

Person ZhangSan =newPerson();//实例化人类为ZhangSan，ZhangSan就是一个对象

——方法Method

方法就是类能够执行的动作

例如：问好，吃饭等

——类的继承

类之间可以有继承关系

例如：”电脑“类可以从“电器”类继承

优点：“电脑”类只需要定义自己特有的字段，方法就可以

父类（Parent）和基类（Base）：电脑类是电器的子类

——面向对象的三个特性

封装，继承，多态

——成员访问级别

简介：

  1. 字段，方法，属性都可以叫做类的成员，他们都需要定义访问级别
  2. 访问级别的用处在于控制成员在哪些地方可以被访问，这样到达面向对象中“封装的目的

几个访问级别：

1.Public：任何地方都可以访问

2.Private：默认级别，只能由本类中的成员访问

另外还有：internal，protected

例码：

1.访问级别

namespace访问级别

{
    classProgram
    {
        staticvoid Main(string[] args)
        {
            
            Person2 p =newPerson2();//实例化person类为p
            p.Age = 20;
            //p.Name ="ddd";//不可访问
            p.睁眼();//不可访问
            Console.ReadKey();
        }
    }
    //访问级别：
    classPerson2//创建以一个类Person2
    {
        publicint Height;//定义int字段Height
        publicint Age;//定义int字段Age
        privatestring Name;//定义string字段Name
        publicvoid SayHello()
        {
            睁眼();//可以访问
            Console.WriteLine("大家好我叫{0}，我今年岁了{1}，我的身高是{2}",this.Name,this.Age,this.Height);
        }
        
        privatevoid睁眼()
        {
            Console.WriteLine("睁开双眼");
        
        }
 
    }
}


——属性

 惯用法：属性开头字母大写，字段开头字母小写

Get：只读属性，可设置访问级别

Set：只写属性，可设置访问级别

 字段和属性的区别：

属性看似字段，不是字段，可以进行非法值控制，可以设置只读

5.例码：

1.创建一个属性：

classProgram
    {
        privateint age;
        publicint Age//Age没有保存数据，都是保存到age中了
        {
            set//赋值
            {
                if (value < 0)//public字段和属性的区别，可以进行非法设置值的判断
                {
                    return;
                }
                this.age =value;//value代表用户赋值过来的值
            }
            get//取值
            {
                return this.age;
            }  
        }
        publicvoid SayHello()
        {
            Console.WriteLine("我的年龄是{0}", Age);
}

2.没有赋值的属性

classPerson
        {
            publicint Age
            {
                set//没有赋值
                {              
                }
                get//不管调用age时赋的值为多少，返回的值都为3，所以p.Age的值一直为3
                {
                    return 3;
                }
            }
        }
staticvoid Main(string[] args)
        {
            Person p =newPerson();
            p.Age = 30;
            p.Age = p.Age + 1;
            Console.WriteLine(p.Age);
            Console.ReadKey();
        }

3.设置只读属性

classPerson3
        {
            privateint age;
            publicint Age //只读属性
            {
                get {return age; }
            }
            publicvoid IncAge()
            {
                age++;
            }
        }
        staticvoid Main(string[] args)
        {       
            Person3 p3 =newPerson3();
            p3.Age = 20;//不可赋值
            p3.IncAge();
            p3.IncAge();
            Console.WriteLine("年龄为："+p3.Age);
            Console.ReadKey();
            
        }

4.没有特殊的约束，编译器自动识别私有字段和get;，set;代码块

classPerson4
{
    publicint Age
    {
        get; //编译器自动帮我们生成私有字段set，get代码块
        set;
    }
    publicstring Name
    {
        get;
        set;
    }
}
staticvoid Main(string[] args)
        {
            Person4 p4 =newPerson4();
            p4.Age = 30;//可以访问，声明字段
            p4.Name ="张三";
            Console.WriteLine("我叫{}，我的今年{1}岁了",p4.Age,p4.Name);
        }

——对象的引用

简介：

Int ，datetime，bool，char等类型都属于值类型（ValueType）,赋值的时候是传递拷贝

普通的对象则是引用类型，赋值的时候是传递引用

例码：

1.对象的引用

namespace对象的引用
{    classProgram
    {
        staticvoid Main(string[] args)
        {
            //Int，datetime，bool，char等类型都属于值类型（ValueType）,赋值的时候是传递拷贝
            int i = 10;
            int j = i;
            i++;//对j没有影响
            Console.WriteLine(j);//输出结果为10
            //普通的对象则是引用类型，赋值的时候是传递引用
            Person p1 =newPerson(10);//向person中传递参数
            Person p2 = p1;
            p1.Age++;
            Console.WriteLine(p2.Age);//输出结果为11
            Console.ReadKey();
        }
        classPerson
        {
            publicint Age {get;set; }
            public Person(int age)
            {
                this.Age = age;
            }
        }
    }
}

2.通过函数来传递对象

namespace通过函数来传递对象
{
    classProgram
    {
        staticvoid Main(string[] args)
        {
            //Int，datetime，bool，char等类型都属于值类型（ValueType）,赋值的时候是传递拷贝
            int i = 10;
            int j = i;
            i++;//对j没有影响
            Console.WriteLine(j);//输出结果为10
 
            //普通的对象则是引用类型，赋值的时候是传递引用
            Person p1 =newPerson(10);//向person中传递参数
            Person p2 = p1;
            p1.Age++;
            IncAge(p2);
            Console.WriteLine(p2.Age);//输出结果为12
            Console.ReadKey();
        }
        staticvoid IncAge(Person p)
        {
            p.Age++;
        }
        classPerson
        {
            publicint Age {get;set; }
            public Person(int age)
            {
                this.Age = age;
            }
        }
    }
}

——构造函数

简介：

  1. 构造函数用来创建对象，并且在构造函数中对对象进行初始化
  2. 用来创建对象的特殊函数，函数名和类名一样，没有返回值，连void都不用
  3.   构造函数可以有参数，new对象的时候传递函数参数即可
  4. 构造函数可以重载，也就是有多个参数不同点构造函数
  5. 如果不指定构造函数，则类有一个默认的无参构造函数
  6.   如果指定了构造函数，则不再有默认的无参构造函数，如果需要无参构造函数，则需要自己来写

例码：

1.创建一个构造函数

namespace构造函数

{
    classProgram
    {
        staticvoid Main(string[] args)
        {
            Person p1 =newPerson("tom");
        } 
    }
    classPerson
    {
        public Person(string name)
        { 
        
        }
    }
}

2.构造函数的重载

namespace构造函数的重载
{
    classProgram
    {
        staticvoid Main(string[] args)
        {
            Person p1 =newPerson("tom");
            Person p2 =newPerson();
        } 
    }
    classPerson
    {
        //多个构造函数可以实现构造函数的重载
        public Person(string name)//构造函数1，里面没有任何参数
        { 
        
        }
        public Person()//构造函数2，里面没有任何参数
        { 
        
        }
    }
}

3.有参数的构造函数

namespace有参数的构造函数
{
    classProgram
    {
        staticvoid Main(string[] args)
        {
            Person p1 =newPerson("tom");
            Person p2 =newPerson();//初始化对象
        } 
    }
 
    classPerson
    {
        publicstring Name {get;set; }//在后面加上{ get; set; }，就变成了属性
        publicint Age {get;set; }
        public Person(string name)//构造函数1，里面没有任何参数
        { 
        
        }
        public Person()//构造函数2,有参数
        {
            Name ="未命名";
            Age = 0;
        }
    }
}

有参数的构造函数的意义：初始化对象

——继承

简介：

  1. 子类可以可以继承父类中的属性，父类中可以有多个子类
  2.   Object是所有类的基类，所有的类都从 object继承，一个 object指针指向任何对象都行

例码：

1.继承的实例

namespace继承
{
    classProgram
    {
        staticvoid Main(string[] args)
        {
            中国人 c1 =new中国人();
            c1.Name ="李小龙";
            c1.SayHello();
            c1.户口 ="重庆";//声明自己自己特有的属性户口
            c1.功夫();//声明自己特有的属性功夫
 
            韩国人 k1 =new韩国人();
            k1.Name ="李孝利";
            k1.SayHello();
            k1.做泡菜();
            Console.ReadKey();
        }
    }
    classPerson//父类
    {
        publicstring Name {get;set; }
        publicint Age {get;set; }
        publicvoid SayHello()
        {
            Console.WriteLine("{0}:Hello！",this.Name);
        }
    }
    //父类中可以有多个子类
    class中国人 :Person//声明一个子类：中国人
    {
        publicstring户口{get;set; }
        publicvoid功夫()
        {
            Console.WriteLine("我打！！");
        }
    }
    class韩国人 :Person//声明一个子类：韩国人
    {
        publicstring称号{get;set; }
        publicvoid做泡菜()
        {
        Console.WriteLine("泡菜哦依稀啊思密达");
        }
        
    }
}

注意：

//父类与子类的继承优先级别

//可行
            Person p1 = c1;
            p1.SayHello();
 
            Person p2 = k1;
            p2.SayHello();
            
 //不可行
            //中国人c2 = new Person();
            //韩国人k2 = new Person();
 
//Object是所有类的基类，所有的类都从object继承，一个object指针指向任何对象都行
object obj = c1;
            object obj2 = k1;
            object obj3 = p1;

——异常与异常处理

简介：

传统的错误表示方式：错误码。举例。需要知道不同错误码的含义，如果不处理错误码，则程序可能陷入不可以预置的错误。

错误码的缺点：不处理很难发现，每次处理很麻烦，难以看出错误的原因，容易使得程序进入不确定状态

Try catch，Exception ex异常也是对象

Exception类主要属性：Message,StackTrace

发生异常后：程序默认退出，后续代码不会被执行，catch以后的代码则会继续执行。

不要吃掉异常：一般情况下不需要处理异常

扔出自己的异常：thrownewException("需要显示的异常信息");

例码：

1.异常处理的格式

try//代码出错后，try后面的代码不再执行，只执行catch里的代码
            {
               运行的可能出错的代码
            }
            catch(Exception ex)
            {
                代码出错后的处理
            }
//如果代码没有出错，其他代码正常执行

2.Exception的应用

            try
            {
                int i =Convert.ToInt32("ABC");
            }
            catch(Exception ex)
            {
                Console.WriteLine("数据错误" + ex.Message);//ex.Message：错误的信息
                Console.WriteLine("异常堆栈" + ex.StackTrace);//ex.StackTrace，数据错误的点
            }

3.抛出自己要显示的异常信息

static void Main(string[] args)
        { 
           try
            {
                string desc =GetAgeDesc(300);
            }                     
            catch (Exception ex) //throw：扔，catch：抓。出现异常的时候已经new好了一个
            {                   //Exception对象扔（throw）出来，咱么抓住（catch）即可
                Console.WriteLine("数据错误："+ex.Message); //此时的ex.Message调用GetAgeDesc为标准类输出信息
            }
            Console.ReadKey();
        }       
staticstring GetAgeDesc(int age)
        {
            if (age > 0&& age <= 3)
            {
                return"婴幼儿";
            }
            elseif (age > 3&& age <= 18)
            {
                return"青少年";
            }
            elseif (age > 19&& age < 150)
            {
                return"成年人";
            }
            elseif (age < 0)
            {
                thrownewException("你丫来自反物质世界吧");
            }
            else
            {
                thrownewException("骚年你见过老佛爷吧");
            }
        }

——常量与静态成员

  量:常量名要大写，一定不会变化值才能声明为常量

 Const：常量

  例码：

1.声明一个常量

constint pi = 3;//pi声明为常量，常量可以声明成全局常量

2.声明一个全局常量

 publicconstint pi = 3;//public const 不用new一个类就可以直接调用

3.常量的应用

            int r = 10;
            constint pi = 3;//pi声明为常量，常量可以声明成全局常量
            int l = 2 * 3 * r;
            Console.WriteLine("周长：{0}", l);
            //pi = 9;//报错
            int m = 3 * r * r;
            Console.WriteLine("面积:{0}", m);

静态成员：

Static：全局变量

Static方法：不用new就能用的方法，是一个普通函数，在static方法中国可以调用其它static方法，字段，属性，但是不能调用非static方法，字段，属性，在非static方法中可以调用static的方法，字段。

c)        例码：

1.创建一个静态成员

public class Person
    {
        publicstaticint TotalCount;
        publicint Age;
}

2.静态成员的应用

namespace静态成员的应用

{
    classProgram//静态成员
    {
        staticvoid Main(string[] args)
        {
            //Person.Age=30;出错
            Person.TotalCount = 30;//静态成员TotalCount不用new就能调用
            Console.WriteLine((Person.TotalCount));
            DoIt();//静态方法同样不用new
            Dog d =newDog();//非静态成员需要new来实例化一个类
            d.叫唤();
            Person p1 =newPerson();
            p1.Age = 300;
            p1.SayHello();
            Console.ReadKey();
            
        }
    
    
    publicstaticvoid DoIt()
    {
    Console.WriteLine("fff");
    Console.WriteLine("使用全局变量：{0}",Person.TotalCount);
    }
    }
    publicclassPerson
    {
        publicstaticint TotalCount;
        publicint Age;
 
        publicstaticvoid人口汇报()
        {      
            //Console.WriteLine("总人口：{0},年龄：{1}",Age,TotalCount);
            //在static成员中不能直接调用非static成员
        }
        publicvoid SayHello()
        {
            Console.WriteLine("我的年龄{0},全球总人口{1}",Age,TotalCount);
            //在非static成员中可以调用static成员
        }
    }
    publicclassDog
    {
        publicvoid叫唤()
        {
            Console.WriteLine("汪汪：{0}",Person.TotalCount);
        }
    }
}

静态类：

不能被实例化的类就是静态类，一般用来实现一些函数库，***Helper，SqlHelper,PageHelper

例码:

1.静态类的应用

amespace静态类
{
    classProgram
    {
        staticvoid Main(string[] args)
        {
            ConsoleHelper.ReadInt();
            Console.ReadKey();
 
           //ConsoleHelper h =new ConsoleHelper();//静态类不能狗实例化
        }
    }
    staticclassConsoleHelper//声明一个静态类
    {
        publicstaticint ReadInt()//声明一个静态方法
        {
            string str =Console.ReadLine();
            returnConvert.ToInt32(str);
        }
    }
}

——命名空间

简介：

命名空间（namespace），用于解决类重名问题，可以看作类的文件夹

在代码中使用其他类的时候需要using类所在的namespace，例如，System.Collections.ArrayList，快速引入的方法，右键->解析

为什么使用Convert，Console等类不需要自己写using：如果代码和被使用的类在一个namespace则不需要using。

可以修改默认的namespace，因此不要认为在相同文件夹下就不用using，不再相同文件夹下就需要using

 

例码：

1.实例另一个文件夹的类

namespace _11命名空间
{
    classProgram
    {
        staticvoid Main(string[] args)
        {
            Person p1 =newPerson();//实例本命名空间下的类
           //实例本项目hr文件下的Person类就像文件的全路径一样
          _11命名空间.hr.Person p2 =new hr.Person();              
        }
    }
 
    classPerson
    { 
    
    }
}

2.引用命名空间来实现实例令一文件夹下的类

using System;
usingSystem.Collections.Generic;
using System.Linq;
using System.Text;
usingSystem.Threading.Tasks;
using _11命名空间.hr;//如果要使用的类和当前的类不再同一个namespace，则需要添加using引用
using _11命名空间.oa;//同一个文件夹下的类的namespace默认一样，但是允许不一样
using System.Collections; //为方便实例ArrayList而引用的命名空间
namespace _11命名空间
{
    classProgram
    {
        staticvoid Main(string[] args)
        {
            Person p1 = newPerson();//实例本命名空间下的类
            //实例本项目hr文件下的Person类，就像文件的全路径一样
           _11命名空间.hr.Person p2 = new hr.Person();             
            //要实例另一命名空间下的类，还可以增加using引用来实现
            Dog d = newDog();
 
            ArrayList list = newArrayList();
        }
    }
 
    classPerson
    {
       
    }
}

——索引器

 定义索引器的方式:

String this[intindex]{get{return””;}set{}}

其中string为索引器的类型，[]为参数列表。进行索引器写操作就是调用set代码块

在set内部使用value得到用户设置的值，进行读操作就三执行get代码块

 注意：索引器参数可以不止一个，类型也不限于int，几乎可以是任意类型

例码：

1.简单的索引

int[] value ={3,5,9,8};

int i = value[0];//通过[]来引用数组的元素，叫做索引

2.索引的应用

namespace索引器的应用
{
    classProgram
    {
        staticvoid Main(string[] args)
        {
            //int[] value ={3,5,9,8};
            //int i =value[0];//通过[]来引用数组的元素，叫做索引
            
            Person p1=newPerson();
            p1[1]="小明";
            Console.WriteLine(p1[1]+" "+p1[2]);//输出为"小明二毛"
 
            string s ="";
            //s[0] = 'a';//报错,string类的索引器是只读的
            Console.WriteLine(p1["tom",3,9]);//索引的重载
            Console.ReadKey();
        }
    }
    classPerson
    {
        privatestring FirsName ="大毛";
        privatestring SecondNmae ="二毛";
 
        publicstringthis[string name, int x,int y] //string为索引器的数据类型
        {
            get; //只有get，没有set
        }
 
        publicstringthis[int index]
        { 
            set
            {
                if (index == 1)
                {
                    FirsName = value;
                }
                elseif (index == 2)
                {
                    SecondNmae = value;
                }
                else
                {
                    thrownewException("错误的序号");
                }
            }
            get
            {
                if (index == 1)
                {
                    return FirsName;
                }
                elseif (index == 2)
                {
                    return SecondNmae;
                }
                else
                {
                    thrownewException("错误的序号");
                }
            }
        }
    }
}

 

 

 

wentaonpa
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
黑马程序员——Android移动开发源码
04-29
黑马程序员——Android移动开发源码
C#面向对象基础
Make a little progress every day！
03-24 398
一：面向对象的概念（与面向过程对比学习） 1：what？=面向对象是一种符合人类思维习惯的编程思想。 面向对象的编程方式，操作的是一个个的对象，比如你需要操作一个人的移动，你需要先实例化那个人的一个管理类对象，然后告诉这个“人”的对象，你需要移动到什么地方去。然后人就自己走过去了。至于具体是怎样走的，外部不关心，只有“人”对象本身知道。 2：面向对象的三大特征： ①封装性：面向对象的核心思想，它将...
C#与Java的语法差异
swt369的博客
10-14 6058
关于C#与Java的语法差异
C#--继承
萍踪侠影
06-02 266
继承是指一个对象直接使用另一对象的属性和方法 public class A { public A() { } } public class B : A { public B() { } } 示范练习： class Program { static void Main(string[] args) { ...
C# 分部类与分部方法
IT成功之路开始
08-08 1399
一、分部类 　　什么是部分类呢？简单来说就是将一个类型或方法拆分到两个或多个源文件中，每个源文件只包含类型定义的一部分。 　　当使用自动生成的源时，无须重新创建源文件便可将代码添加到类中。Visual Studio在创建Window窗体，Web服务包装代码时都是使用此方法。 分部类的特征  1、类的定义前要加partial。  2、分部类可以定义在两个不同的.cs文件，也可以定义在同一个
public static void main(String[] args){}函数诠释
热门推荐
Chen
07-25 1万+
主函数的一般写法如下：　　public static void main(String[] args){…}　　下面分别解释这些关键字的作用：　　（1）public关键字，这个好理解，声明主函数为public就是告诉其他的类可以访问这个函数。　　（2）static关键字，告知编译
黑马程序员——赢在习惯
04-07
NULL 博文链接：https://xianglachigen.iteye.com/blog/1564376
黑马程序员Javase笔记
01-18
正在自学黑马程序员Java全套，目前只学了Javase，接下来是Javaweb，把自己整理的笔记分享一下。
黑马程序员 大事件案例程序
08-24
layui ajax 没有node.js功能都可用，高度类似。 黑马刘龙彬老师主讲的大事件项目，整体看完，给...最后，再次给黑马程序员和刘老师点个赞。 说明--ShowDoc https://www.showdoc.com.cn/escook?page_id=3707158761215217
JAVA-面向对象基础-字符串-集合
09-27
观看黑马程序员Java零基础视频教学，从60P方法开始总结的知识集合，请使用Xmind打开，如果需要学习请配合视频打开：https://www.bilibili.com/video/BV17F411T7Ao
delegate-2
qq_43615903的博客
06-21 253
using System; namespace Delegate2 { class Program { static void Main(string[] args) { Person p = new Person(); p.Greeting("张三", "en"); p.Greeting("张三", "ch");
静态类，方法，成员
qq_36662910的博客
12-30 453
c#静态类，方法,成员
菜鸟升级记——里式转换原则
Jun5203
02-13 368
  学了很长一段时间的C#，当时对于一些理论东西还是比较明白的，但是随着时间的推移，有很多知识点变得模糊，所以就体现出及时总结的好处。还是那句“欠下的总归要还的”，及时总结真的很重要！那里氏转换是如何实现的，下面就跟着小编来学习一下吧！ 前提：Teacher和Student继承Person，且Teacher、Student和Person都有一个相同名称的方法。 public class Pe...
C#总结（续篇）
李勇杰
10-13 705
访问修饰符 private：私有的，父类的字段只能在父类中使用，子类中不可以调用 public：公有的，所有的类都可以访问 protect：保护的，在继承的基础上衍生出来的，父类的方法只能子类调用，其他的类不可以调用 internal：只能在同一程序集中访问，即使internal protect也表示不仅能访问子类，只要是在同意程序集所有的类都可以访问。 class VS struct定义publi
C#基础 构造函数（方法）
Peter的博客
03-02 1858
一、定义类 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace oop { class Student // 默认internal族类（项目内）, 改为public后其它命名空间可引用并使...
c#静态成员和静态类
weixin_30872789的博客
03-03 69
说起静态类，你可能会联想到实例类。这两者并不难区分，前者(静态类)只在内存中创建一个，而后者(实例类)则是每次实例化后，就会再内存创建一份。今天来简单聊一下静态类的理解。 代码情景： class Program { static void Main(string[] args) { Person p1 = new Person();...
多线程学习——JAVA三种线程的创建方式
swy66的博客
09-24 307
​ Java中有三种线程创建方式，分别为继承Thread类并重写run的方法，实现Runnable接口的run方法，使用FutureTask方式。 继承Thread类方式的实现。 public class Thread1 extends Thread { @Override public void run() { for(int i=1;i<=10;i++) { System.out.println("多线程执行中..."+i); } } public static v
黑马程序员tb——brand
最新发布
07-27
黑马程序员的tb_brand是指在JavaWeb基础教程中创建的一个表。这个表是用来存储品牌信息的，具体的表结构和数据类型需要和JavaBean类中的成员变量保持一致。\[1\]在这个教程中，使用了Maven来构建项目，并且使用了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值