Lession05类和对象的高级应用
2021-06-08 本文已影响0人
任人渐疏_Must
访问修饰符
/*
* 面向对象的三大特点：
* 1.封装：将数据或函数（行为）等集合在一个个单元中（我们称之为类）
* 2.继承：类似于现实世界继承的意思，子类继承父类（第八章学）
* 3.多态：一个事物（类）有多种表现形式（第八章学）
*
* 我们可以通过调用封装好的单元，获取其中的数据和函数，但有些数据和函数不希望被每个人获得
* 所以就用到了访问修饰符，利用访问修饰符封装成员变量及方法，限制类成员的访问权限
* public:公共的，无限制条件，任何代码都可以访问
* private:私有的，只有所在类的成员才能访问
*
* 总结：访问修饰符的作用是修饰类的成员变量，对类成员变量的可访问性进行限制
* 1声明命名空间、类，前面不加限制访问修饰符时，默认访问权限为internal——访问仅限于当前程序集。
* 2.声明类成员(属性和方法)默认为private）前面不加限制访问修饰符时，
* 默认访问权限为private——访问仅限于当前类。
*
*
*/
class Student
{
//创建三个公开的成员变量
public int id;
public string name;
public int age;
//私有变量
private int score;
//私有变量，其他类不能访问修改，只能在本类代码中访问修改
public void ModifyScore()
{
//访问本类私有变量，并赋值
this.score = 90;
Console.WriteLine("{0}的分数是{1}", this.name, this.score);
}
}
class Program
{
static void Main(string[] args)
{
//实例化一个Student类
Student stu = new Student();
//对stu对象的两个成员变量赋值
//虽然是Student类中的成员变量，但因为访问修饰符是public，可以在任何类中访问，
//所以在Program类中可以使用，并且赋值
stu.id = 1001;
stu.name = "张三";
stu.age = 20;
stu.ModifyScore();
Console.WriteLine("姓名是{0},编号是{1},年龄是{2}", stu.name, stu.id, stu.age);
//实例化第二个对象
Student stu2 = new Student();
stu2.id = 1002;
stu2.name = "李四";
stu2.age = 18;
stu2.ModifyScore();
Console.WriteLine("姓名是{0},编号是{1},年龄是{2}", stu2.name, stu2.id, stu2.age);
Console.ReadKey();
}
}
值类型和引用类型
/*
* 值类型和引用类型
* 区别：
* 1、值类型和引用类型在内存上存储的地方不一样。
* 2、在传递值类型和传递引用类型的时候，传递的方式不一样。
* 值类型我们称之为值传递，引用类型我们称之为引用传递。
* 我们学的值类型和引用类型：
* 值类型：int、double、bool、char、decimal、struct、enum
* 引用类型：string、自定义类、数组
* 存储：
* 值类型的值是存储在内存的栈当中。
* 引用类型的值是存储在内存的堆中。
*
*
*
*/
public class Student
{
public int id;
}
class Program
{
static void Main(string[] args)
{
//值类型
//声明一个值类型的整数数据类型
int n = 100;
Console.WriteLine("该变量的初始值为{0}", n);
Test(n);//方法调用完，就弹出栈了，由于是值类型，所以就有恢复其初始值
Console.WriteLine("该变量的值此时是{0}", n);
//引用类型
Student stu = new Student();
stu.id = 100;
//传递属于引用类型的对象
Test2(stu);
Console.WriteLine("stu.id的值是{0}",stu.id);
//装箱
int i = 123;
object o = i;//值类型，转为引用类型 装箱
int j = (int)o;//拆箱
Console.WriteLine("o的值是{0}",o);
Console.WriteLine("j的值是{0}", j);
Console.ReadKey();
}
static void Test(int i)
{
int temp = 10;
i = temp * 20;
}
static void Test2(Student s)
{
int temp = 10;
s.id = temp * 20;
}
}
类的静态成员
/*
* 静态和非静态的区别:
* 1)、在非静态类中，既可以有实例成员，也可以有静态成员。
* 2)、在调用实例成员的时候，需要使用对象名.实例成员;
* 在调用静态成员的时候，需要使用类名.静态成员名;
* 总结：静态成员必须使用类名去调用，而实例成员使用对象名调用。
*
*静态函数中，只能访问静态成员，不允许访问实例成员。
*实例函数中，既可以使用静态成员，也可以使用实例成员。
*静态类中只允许有静态成员，不允许出现实例成员。
* 使用：
*1)、如果你想要你的类当做一个"工具类"去使用，这个时候可以考虑将类写成静态的。
*2)、静态类在整个项目中资源共享。
*只有在程序全部结束之后，静态类才会释放资源。
*
*释放资源。GC Garbage Collection垃圾回收器
*/
class Program
{
static void Main(string[] args)
{
//调用实例成员
Person p = new Person();
p.M1();
//调用静态方法
Person.M2();
Student.M1();
Console.ReadKey();
}
}
class Person
{
//静态成员name
public static string name;
//非静态成员gender
public char gender;
public void M1()
{
this.gender = '男';//实例函数，即可以访问实例成员，也可以访问静态成员
name = "李四";
Console.WriteLine("这是非静态方法");
}
public static void M2()
{
name = "张珊"; //静态函数，只能访问静态成员，不能访问实例成员
Console.WriteLine("这是静态方法");
}
}
//静态类
public static class Student
{
public static string name;
// public int age;//静态类不能使用实例成员
public static void M1()
{
Console.WriteLine("HELLO ,我是静态类中的静态方法");
}
//public void M2() //静态类不能使用实例方法
//{
//}
}
ref关键字和out关键字
class Program
{
/*
* 值类型数据作为参数，修改形参时不会影响实参，
* 而引用类型的数据作为参数，修改形参可以影响到实参
*
* ref与out都是把实参按照引用类型方式传递
* 区别:传递到ref的参数必须最先初始化，而out的参数在传递之前不需要初始化，需要在方法返回之前赋值
* ref重在修改参数的数据，而out重在带回执行结果
*
*
*/
static void Main(string[] args)
{
//ref
int val = 0;
M1(ref val);
Console.WriteLine("val的值是{0}",val);
//out
int val2;
M2(out val2);
Console.WriteLine("val2的值是{0}", val2);
Console.WriteLine("------------------------------------");
int n1 = 10;
int n2 = 20;
Console.WriteLine("交换前两个数的值分别是{0}，{1}",n1,n2);
Swap(ref n1, ref n2);
Console.WriteLine("交换后两个数的值分别是{0}，{1}", n1, n2);
Console.ReadKey();
}
static void M1(ref int i)
{
i = 44;
}
static void M2(out int i)
{
i = 45;
}
public static void Swap(ref int n1,ref int n2)
{
int temp;
temp = n1;
n1 = n2;
n2 = temp;
}
}
方法的重载
/*概念：方法的重载就是方法的名称相同，但是参数不同
* 参数不同，分两种：
* 1.如果参数的个数相同，那么参数的类型就不能相同
* 2.如果参数的类型相同，那么参数的个数就不能相同
* 注意：
* 方法的重载跟它的返回值类型没有关系
*
*
*
*
*/
class Program
{
static void Main(string[] args)
{
// M();
Console.WriteLine(1); //按F12可以进到它的类中
Console.WriteLine(1.5);
Console.WriteLine(true);
Console.WriteLine('A');
Console.WriteLine(1000M);
Console.WriteLine("Hello World!");
Console.ReadKey();
}
public static void M(int n1, int n2)
{
int res = n1 + n2;
}
public static double M(double n1, double n2)
{
return n1 + n2;
}
public static void M(int n1, int n2, int n3)
{
int res = n1 + n2 + n3;
}
public static string M(string s1, string s2)
{
return s1 + s2;
}
}
