using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace x类和方法_19_4_9
{
public class stu
{
//字段--值--与普通的变量类型--但要有权限
//为了数据的安全，一个班所有字段都是私有的
private string num;//学号
private string name;//姓名
private double sql;//成绩
private double oracle;
private double sum;//总分
private double avg;//平均分
//静态的成员变量--字段
//静态的成员变量属于类公有的属性，而不是属于对象的
//定义静态的成员变量一般要给初始值
//班费
public static double mon = 2000;
//静态的成员方法属于类不属于对象，只能访问静态成员变量
//交班费
public static void addmon(double n)
{
//mon=mon+n;
mon+=n;
}
//求总分的方法
//方法也可以是私有的
private void calc()
{
sum = sql+oracle;
avg = sum / 2;
}
//行为--功能--方法
//输出
//
//所有私有字段，在外部一般都是通过公有的方法来操作的
//行为--功能--方法
//所有的类方法没有static关键字
//类中的字段可以直接引用
public void print()
{
calc();//私有方法要在公有方法里面调用
Console.WriteLine("-------学生信息--------");
Console.WriteLine("学号：{0}",num);
Console.WriteLine("姓名：{0}",name);
Console.WriteLine("sql成绩：{0}",sql);
Console.WriteLine("oracle成绩{0}",oracle);
Console.WriteLine("成绩总和{0}", sum);
Console.WriteLine("平均成绩{0}", avg);
}
//把赋值设计为方法
//技巧：1、有几个要赋值的字段，形参就要有几个，2，形参的类型与要赋值的字段类型相同
public void set(string num, string name, double sql, double oracle)
{
//在类的赋值方法中一般为可读性，形参的类型与要赋值的字段类型相同
//但是num=num，编译系统认为是把形参num赋值给了自身
//所以要引用类对象的字段，前面必须是用this.指针
this.num = num;
this.name = name;
this.sql = sql;
this.oracle = oracle;
}
//构造方法是创建对象且分配资源的功能方法，new调用它
//所以有一个系统默认的构造方法；现在我们的创建对象的语句是（）。所以系统的构造方法是无参的
//我们可以自定义构造方法，但是你一旦定义构造方法，系统就被覆盖了
//自定义的构造方法：1、构造方法名与类名相同 没有返回值 ，连void都没有
//2、我们一般要么不写构造方法，要么至少要写两个，一个是无参的（给默认值）一个是带参的
//所以构造方法是可以重载的
//无参数的构遭方法
public stu()
{
num = "x180803";
name = "令狐冲";
sql = 89.9;
oracle = 98.8;
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace x类和方法_19_4_9
{
class Program
{
//类是c#中允许用户自定义的一种结构
//类是一个独立的模块--最好把类单独一个文件
static void Main(string[] args)
{
//类是抽象的，概念的，在c# 中是一个结构，所以要用这个结构定义变量（对象）
//利用类创建对象 类 对象名 = new 类（）；
stu a = new stu();
//对象具有类的所有字段，方法
a.set("x180802", "赵明",88.8,99.9);
a.print();
//练习:定义第二个对象b
stu b = new stu();
b.set("x180802", "赵敏", 88.8, 77.7);
b.print();
stu c = new stu();
c.print();
//输出班费
Console.WriteLine("班费"+stu.mon);
//调用方法交班费
stu.addmon(555.5);
//交完班费再输出
Console.WriteLine("交完班费"+stu.mon);
//停止看结果
Console.ReadLine();
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace x类和方法_19_4_9
{
class Program
{
//类是c#中允许用户自定义的一种结构
//类是一个独立的模块--最好把类单独一个文件
static void Main(string[] args)
{
//类是抽象的，概念的，在c# 中是一个结构，所以要用这个结构定义变量（对象）
//利用类创建对象 类 对象名 = new 类（）；
stu a = new stu();
//对象具有类的所有字段，方法
a.set("x180802", "赵明",88.8,99.9);
a.print();
//练习:定义第二个对象b
stu b = new stu();
b.set("x180802", "赵敏", 88.8, 77.7);
b.print();
stu c = new stu();
c.print();
//输出班费
Console.WriteLine("班费"+stu.mon);
//调用方法交班费
stu.addmon(555.5);
//交完班费再输出
Console.WriteLine("交完班费"+stu.mon);
//停止看结果
Console.ReadLine();
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace x类和方法_19_4_9
{
public class stu
{
//字段--值--与普通的变量类型--但要有权限
//为了数据的安全，一个班所有字段都是私有的
private string num;//学号
private string name;//姓名
private double sql;//成绩
private double oracle;
private double sum;//总分
private double avg;//平均分
//静态的成员变量--字段
//静态的成员变量属于类公有的属性，而不是属于对象的
//定义静态的成员变量一般要给初始值
//班费
public static double mon = 2000;
//静态的成员方法属于类不属于对象，只能访问静态成员变量
//交班费
public static void addmon(double n)
{
//mon=mon+n;
mon+=n;
}
//求总分的方法
//方法也可以是私有的
private void calc()
{
sum = sql+oracle;
avg = sum / 2;
}
//行为--功能--方法
//输出
//
//所有私有字段，在外部一般都是通过公有的方法来操作的
//行为--功能--方法
//所有的类方法没有static关键字
//类中的字段可以直接引用
public void print()
{
calc();//私有方法要在公有方法里面调用
Console.WriteLine("-------学生信息--------");
Console.WriteLine("学号：{0}",num);
Console.WriteLine("姓名：{0}",name);
Console.WriteLine("sql成绩：{0}",sql);
Console.WriteLine("oracle成绩{0}",oracle);
Console.WriteLine("成绩总和{0}", sum);
Console.WriteLine("平均成绩{0}", avg);
}
//把赋值设计为方法
//技巧：1、有几个要赋值的字段，形参就要有几个，2，形参的类型与要赋值的字段类型相同
public void set(string num, string name, double sql, double oracle)
{
//在类的赋值方法中一般为可读性，形参的类型与要赋值的字段类型相同
//但是num=num，编译系统认为是把形参num赋值给了自身
//所以要引用类对象的字段，前面必须是用this.指针
this.num = num;
this.name = name;
this.sql = sql;
this.oracle = oracle;
}
//构造方法是创建对象且分配资源的功能方法，new调用它
//所以有一个系统默认的构造方法；现在我们的创建对象的语句是（）。所以系统的构造方法是无参的
//我们可以自定义构造方法，但是你一旦定义构造方法，系统就被覆盖了
//自定义的构造方法：1、构造方法名与类名相同 没有返回值 ，连void都没有
//2、我们一般要么不写构造方法，要么至少要写两个，一个是无参的（给默认值）一个是带参的
//所以构造方法是可以重载的
//无参数的构遭方法
public stu()
{
num = "x180803";
name = "令狐冲";
sql = 89.9;
oracle = 98.8;
}
}
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace x属性设计_19_4_9
{
//索引器例子
class stuTeam
{
//字段
private stu [] student;
//创建有参数构造方法
public stuTeam(int i)
{
this.student = new stu[i];
}
//创建索引器，按索引（下标）访问
public stu this[int index]
{
get
{
if (index < 0 || index >= student.Length)
{
Console.WriteLine("索引值超出范围！");
return null; //返回空值
}
return student[index];
}
set
{
this.student[index] = value;
}
}
//索引器重载--按索姓名访问
public stu this[string Name]
{
get
{
foreach (stu s in student )
{
if (s.Name == Name) return s; //有与对象姓名符合的学生，则返回该学生信息
}
Console.WriteLine("没有符合条件的学生信息！");
return null;
}
}
}
//主方法
//索引器
//定义一个包含5个学生的集合
stuTeam st = new stuTeam(5);
//赋值
stu s1 = new stu("X170401", "Rose", -20, 85);
stu s2 = new stu("X170402", "Jack", 77, 120);
stu s3 = new stu("X170403", "张三", 77, 66);
stu s4 = new stu("X170404", "李四", 55, 83);
stu s5 = new stu("X170405", "王五", 63, 81);
st[0] = s1;
st[1] = s2;
st[2] = s3;
st[3] = s4;
st[4] = s5;
//输出
Console.WriteLine("学号\t姓名\tSQL\tORACLE\t");
Console.WriteLine("---------------------------------");
for (int i = 0; i < 5; i++)
{
Console.WriteLine("{0}\t{1}\t{2}\t{3}\t", st[i].Num, st[i].Name, st[i].Sql, st[i].Oracle);
}
//搜索信息
//按索引值进行搜索
Console.WriteLine("请输入要查找的学生索引值");
int n = int.Parse(Console.ReadLine());
stu ss = st[n];
if(ss!=null )
{
Console.WriteLine("{0}\t{1}\t{2}\t{3}\t", ss.Num, ss.Name, ss.Sql, ss.Oracle);
}
//按姓名查找
Console.WriteLine("请输入要查找的学生姓名");
string m = Console.ReadLine();
ss = st[m];
if(ss!=null )
{
Console.WriteLine("{0}\t{1}\t{2}\t{3}\t", ss.Num, ss.Name, ss.Sql, ss.Oracle);
}
//程序等待
Console.ReadLine();
}
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace 结构体
{
class Program
{
//结构体与类一样，是独立的模块，放在主方法的外部--上面
//(1)结构体的关键字是struct
struct stu
{
//(2)由于结构体没有封装性，字段一般为公有的
//学号
public string num;
//快捷键：prop+tab两次:快捷键生成属性
public string Num //公共的属性
{
get//读取
{
return num;//读取，利用return语句返回该字段的值
}
set //写入
{
num = value;//写入，value是一个关键字，表示一个值
}
}
//姓名
private string name;
public string Name
{
get
{
return this.name;//读取，利用return语句返回该字段的值
}
set
{
this.name = value;//写入，value是一个关键字，表示一个值
}
}
//属性的第一好处就是封装之后在外面能够对单个字段进行读写，第二个好处就是可以加约束
//两门课
private double sql;
public double Sql
{
get
{
return sql;//读取，利用return语句返回该字段的值
}
set
{
//约束一般是对set部分写入
if (value >= 0 && value <= 100)
{
sql = value;
}
else
{
sql = 0;//非法成绩-------不在范围内的成绩，给0
}
}
}
private double oracle;
public double Oracle
{
get
{
return oracle;//读取，利用return语句返回该字段的值
}
set
{
//约束一般是对set部分写入
if (value >= 0 && value <= 100)
{
oracle = value;
}
else
{
oracle = 0;//非法成绩-------不在范围内的成绩，给0
}
}
}
//总分
private double sum;
//平均分
private double ave;
//特定功能--方法
//输出
public void print()
{
Console.WriteLine("\n学号：{0}", num);
Console.WriteLine("姓名：{0}", name);
Console.WriteLine("SQL：{0}", sql);
Console.WriteLine("ORACLE：{0}", oracle);
Console.WriteLine("总分：{0}", sum);
Console.WriteLine("平均分：{0}", ave);
}
//(3)结构体没有无参数构造方法
//(4)如写有参数构造方法，则需完全赋值
public stu(string num, string name, double sql, double oracle)
{
//num = num;系统认为是：形参num赋值给了形参num
//希望形参和属性同名--this指针--指向类本身的
num = num;
name = name;
sql = sql;
this.oracle = oracle;
sum = sql + oracle;
ave = sum / 2;
}
}
static void Main(string[] args)
{
//定义结构体变量并操作
stu a = new stu("X170401", "Rose", 87, 85);
a.print();
//程序等待
Console.ReadLine();
}
}
}
浙公网安备 33010602011771号