c#和unity引擎的所有笔记
Shader摄像机死亡效果作者： 1056923207@qq.com |
1：Shader脚本
Shader "Custom/CameraShader"
{
Properties
{
_MainTex( "MainTexture",2D )= "white" {}
}
SubShader
{
Tags{"RenderType"= "Opaque"}
LOD 200
Pass
{
CGPROGRAM
#pragma vertex vert
#pragma fragment frag
#include "UnityCG.cginc"
sampler2D _MainTex;
void vert ( inout appdata_base v)
{
v.vertex=mul(UNITY_MATRIX_MVP,v.vertex);
}
float4 frag( appdata_base v):COLOR
{
fixed4 c= tex2D(_MainTex,v.texcoord);
fixed d = 0.3*c.r+0.59*c.g+0.11*c.b;
return fixed4 (d,d,d,1);
}
ENDCG
}
}
}
2：摄像机上挂载的脚本：
using UnityEngine;
using System.Collections;
public class CameraTest : MonoBehaviour {
public Material material;
//相机的回调函数
void OnRenderImage( RenderTexture rest/*相机渲染的图像*/ , RenderTexture dest /*经过Shader渲染后的图像*/ )
{
Graphics.Blit(rest, dest, material);//摄像机渲染好的图像经过处理再显示出来
}
}
快速排序作者： 1056923207@qq.com |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace QuickSort
{
class Program
{
static void Main(string[] args)
{
int[] arr = new int[8000000];
for (int i = 0; i < arr.Length; i++)
{
arr[i] = 8000000 - i;
}
kuaisu(arr, 0, arr.Length - 1);
//BuddleSort(arr);
foreach (var item in arr)
{
Console.WriteLine(item);
}
}
//普通冒泡排序
public static void BuddleSort( int[] arr)
{
for (int i = 0; i < arr.Length-1; i++)
{
for (int j = 0; j < arr.Length-1-i; j++)
{
if (arr[j]>arr[j+1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
//快速排序
public static void kuaisu( int [] arr,int left,int right)
{
if (left>=right)
{
return;
}
if (left<right)
{
int middle = arr[(left + right) / 2];
int i = left-1;
int j = right+1;
while (true )
{
while (arr[++i] < middle) { }
while (arr[--j] > middle) { }
if (i>=j)
{
break;
}
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
kuaisu(arr, left, i - 1);
kuaisu(arr, j + 1, right);
}
}
}
}
Shader来源网址： http://www.jianshu.com/p/7b9498e58659作者： 1056923207@qq.com |
最他妈好的解释 没有之一
struct SurfaceOutput {
half3 Albedo; // 纹理颜色值（r, g, b)
half3 Normal; // 法向量(x, y, z)
half3 Emission; // 自发光颜色值(r, g, b)
half Specular; // 镜面反射度
half Gloss; // 光泽度
half Alpha; // 不透明度};
ambient 环境光
Shader作者： 1056923207@qq.com |
shader数据类型
fixed 取值范围[-2,2]
half
double
网络作者： 1056923207@qq.com |
同步动画 在人物身上绑定来性格组件：networkidentity，
Out和Ref的区别来源网址： http://www.cnblogs.com/sjrhero/articles/1922902.html作者： 1056923207@qq.com |
out的使用
—————————————————————————————————————————————————
class Program
{
static void Main(string[] args)
{
string tmp; //先声明，但不初始化
User _user=new User();
_user.Name(out tmp); //调用Name方法
Console.WriteLine("{0}",tmp); //这时tmp的值为“在这里面赋值了”
Console.ReadKey(true);
}
}
class User
{
public void Name(out string tmps)
{
tmps="在这里面赋值了";
}
}
结果：
在这里面赋值了
—————————————————————————————————————————————————
ref的使用
—————————————————————————————————————————————————
class Program
{
static void Main(string[] args)
{
string tmp="传值之前"; //声明并初始化 这时如果输出tmp值为"传值之前"
User _user=new User();
_user.Name(ref tmp);
Console.WriteLine("{0}",tmp);
Console.ReadKey(true);
}
}
class User
{
public void Name(ref string tmps)
{
tmps="传值之后";
}
}
结果：
传值之后
—————————————————————————————————————————————————
区别：
ref和out的区别在C# 中，既可以通过值也可以通过引用传递参数。通过引用传递参数允许函数成员更改参数的值，并保持该更改。若要通过引用传递参数， 可使用ref或out关键字。ref和out这两个关键字都能够提供相似的功效，其作用也很像C中的指针变量。它们的区别是：
1、使用ref型参数时，传入的参数必须先被初始化。对out而言，必须在方法中对其完成初始化。
2、使用ref和out时，在方法的参数和执行方法时，都要加Ref或Out关键字。以满足匹配。
3、out适合用在需要retrun多个返回值的地方，而ref则用在需要被调用的方法修改调用者的引用的时候。
out
方法参数上的 out 方法参数关键字使方法引用传递到方法的同一个变量。当控制传递回调用方法时，在方法中对参数所做的任何更改都将反映在该变量中。
当希望方法返回多个值时，声明 out 方法非常有用。使用 out 参数的方法仍然可以返回一个值。一个方法可以有一个以上的 out 参数。
若要使用 out 参数，必须将参数作为 out 参数显式传递到方法。out 参数的值不会传递到 out 参数。
不必初始化作为 out 参数传递的变量。然而，必须在方法返回之前为 out 参数赋值。
属性不是变量，不能作为 out 参数传递。
ref是 有进有出，而out是 只出不进。
根据Txt文件数据生成地图作者： 1056923207@qq.com |
往文件写东西用：FileStream;
从文件读东西用：StreamReader；
字符串转化为字节的区别：
一个一个转换： this.data[i, j] = byte .Parse(data[i][j].ToString());
多个转换 byte[] map = Encoding .UTF8.GetBytes(sb.ToString());//想得到什么类型的数据就Get什么
using UnityEngine;
using System.Collections;
using UnityEditor;
using System.IO;
using System.Text;
public class MapBuilder : Editor{
public const int RowCount = 6;
public const int ColCount = 6;
[MenuItem( "Map/Build")]
static void BuildMap()
{
//创建地图10*10
//规则：蓝色是海洋，红色是障碍物，黄色是终止点
byte[,] map = GetMapData();
GameObject Roads = new GameObject( "Roads");
GameObject BlueCube = Resources .Load("Blue") as GameObject ;
GameObject RedCude = Resources .Load("Red") as GameObject ;
for (int i = 0; i <RowCount; i++)
{
for (int j = 0; j < ColCount; j++)
{
switch (map[i,j])
{
case 1:
GameObject RCube= Instantiate(RedCude) as GameObject;
RCube.transform.SetParent(Roads.transform);
RCube.transform.position = new Vector3 (-17.5f + i, 0, j + 17.5f );
RCube.transform.localScale = Vector3.one * 0.8f;
RCube.name = i.ToString() + "_" + j.ToString();
break;
case 2:
GameObject Bcube= Instantiate(BlueCube) as GameObject;
Bcube.transform.SetParent(Roads.transform);
Bcube.transform.position = new Vector3 (-17.5f + i, 0, j + 17.5f );
Bcube.transform.localScale = Vector3.one * 0.8f;
Bcube.name = i.ToString() + "_" + j.ToString();
break;
default:
GameObject cube= GameObject .CreatePrimitive(PrimitiveType.Cube);
cube.transform.SetParent(Roads.transform);
cube.transform.position = new Vector3 (-17.5f + i, 0, j + 17.5f);
cube.transform.localScale = Vector3.one * 0.8f;
cube.name = i.ToString() + "_" + j.ToString();
break;
}
}
}
}
//从地图取数据
[MenuItem( "Map/Test")]
static byte[,] GetMapData()
{
string path = Application .dataPath + "/Map/Map1.txt";
//文件读写流
StreamReader sr = new StreamReader(path); //读取文件并且将文件中的内容放到sr中
string result = sr.ReadToEnd(); //读取内容(从当前位置到末尾读取)
string[] data = result.Split(new char[] { '\n'});//逐行截取,生成的数据就是一行一行的
byte[,] mapdata = new byte[RowCount, ColCount]; //定义一个二维数组
Debug.Log(data.Length);
for (int i = 0; i < RowCount; i++)
{
for (int j = 0; j < ColCount; j++)
{
mapdata[i, j] = byte.Parse(data[i][j].ToString());//将字符串存入到二维数组
}
}
return mapdata;
}
//往地图写数据
[MenuItem( "Map/CreateMap")]
static void CreateMap()
{
//第一步访问txt文件
string path = Application .dataPath + "/Map/Map1.txt";
FileStream fs= File .OpenWrite(path);//可以对文件进行操作
//第二步填充内容
StringBuilder sb = new StringBuilder(); //容量可变的字符串数组
for (int i = 0; i < RowCount; i++)
{
for (int j = 0; j < ColCount; j++)
{
sb.Append( Random.Range(0, 3));//给字符串添加值
}
sb.AppendLine(); //换行
}
byte[] map = Encoding .UTF8.GetBytes(sb.ToString());//想得到什么类型的数据就Get什么
fs.Write(map, 0, map.Length); //将Map写到文件中，从map的第0个空间开始，长度为length
fs.Close(); //关闭流
fs.Dispose(); //释放资源
AssetDatabase.Refresh();//刷新资源显示
}
}
A*算法作者： 1056923207@qq.com |
using UnityEngine;
using System.Collections.Generic;
using System.IO;
using System.Text;
public class AStar : MonoBehaviour {
#region 字段
byte[,] mapData; //存储地图数据的数组
int rowCount; //地图行数
int colCount; //地图列数
string mappath;
Transform Player; //小球
Vector2 start; //起始点
Vector2 end; //终止点
Vector3 MoveDir; //移动的方向
Vector3 Target; //移动的下一个目标
//存放待访问节点
List< Node> list = new List< Node> ();
//存放已经访问过的节点
List< Node> visited = new List< Node>();
//存放小球的路径点
Stack< Vector2> path = new Stack< Vector2>();
//方向
Vector2[] dirs = new Vector2 [] { Vector2.left, Vector2.right, Vector2 .up, Vector2.down ,
new Vector2(1, 1), new Vector2 (1, -1), new Vector2(-1, -1), new Vector2 (-1, 1) };
#endregion
#region 方法
void Start()
{
string datapath = Application .dataPath + "/Map/Map2.txt";
LoadMapData(datapath); //加载地图数据
CreateMap(); //根据地图数据创建地图
BFS(); //查找一条最优路径
Player = GameObject.CreatePrimitive(PrimitiveType .Sphere).transform;
Player.transform.position = GetPosition(start);
Target = GetPosition(path.Peek()); //取出最上面的值
}
void Update()
{
MoveDir = (Target - Player.position).normalized;
Player.Translate(MoveDir * Time.deltaTime);
if (Vector3 .Distance(Player.position,Target)<0.1f)
{
path.Pop(); //出栈操作（取出来栈里面就没有该元素了）如果用Peek还会存在
if (path.Count == 0)
{
this.enabled = false ;//脚本失效
}
else
{
Target = GetPosition(path.Peek());
}
}
}
void LoadMapData( string Path)
{
StreamReader sr = new StreamReader(Path);
string content = sr.ReadToEnd();
string[] Mapdata = content.Split(new string[] {"\r\n"},System.StringSplitOptions .RemoveEmptyEntries);//清除空格
rowCount = Mapdata.Length;
colCount = Mapdata[0].Trim().Length;
mapData = new byte [rowCount, colCount];
//Debug.Log(rowCount +" "+ colCount);
for (int i = 0; i < rowCount; i++)
{
for (int j = 0; j < colCount; j++)
{
mapData[i,j] = byte.Parse(Mapdata[i][j].ToString());
// Debug.Log(mapData[i,j]);
}
}
sr.Close();
sr.Dispose();
}
Vector3 GetPosition( int x,int y)
{
float pos_x = -rowCount * 0.5f + y;
float pos_y = -colCount * 0.5f - x;
return new Vector3(pos_x, 0, pos_y);
}
Vector3 GetPosition( Vector2 point)
{
float pos_x = -rowCount * 0.5f + point.y;
float pos_y = -colCount * 0.5f - point.x;
return new Vector3(pos_x, 1, pos_y);
}
/// <summary>
/// 获取起始点和终止点
/// </summary>
void GetStartEnd()
{
for (int i = 0; i < mapData.GetLength(0); i++)
{
for (int j = 0; j < mapData.GetLength(1); j++)
{
if (mapData[i,j]==0)
{
start.x = i;
start.y = j;
}
else if (mapData[i,j]==9)
{
end.x = i;
end.y = j;
}
}
}
}
int NodeSort( Node x, Node y)
{
if (x.F == y.F)
{
return 0;//表示不交换位置
}
else if (x.F > y.F)
{
return 1;//表示交换位置
}
else
{
return -1;//表示不交换位置
}
}
bool IsOk( Vector2 point)
{
//越界
if (point.x<0||point.y<0||point.x>=mapData.GetLength(0)||point.y>= mapData.GetLength(1))
{
return false ;
}
//障碍物
if (mapData[(int )point.x, (int)point.y]==2)
{
return false ;
}
//已访问
for (int i = 0; i < visited.Count; i++)
{
if (visited[i].x==(int )point.x&&visited[i].y==(int)point.y)
{
return false ;
}
}
for (int i = 0; i < list.Count; i++)
{
if (list[i].x == (int )point.x && list[i].y==(int)point.y)
{
return false ;
}
}
return true ;
}
//搜索最短路径
void BFS()
{
//给起始点和终止点赋值
GetStartEnd();
//创建起始节点看，进入队列
Node root = new Node(start);
list.Add(root);
//开始检索
while (list.Count > 0)
{
//先按照F值排序，后去F值最小的节点
list.Sort(NodeSort);
Node node =list[0];
list.Remove(node); //移除，以跳出循环
visited.Add(node); //添加节点到已经访问过的集合
for (int i = 0; i < dirs.Length; i++)
{
Vector2 point;
point.x = node.x + dirs[i].x;
point.y = node.y + dirs[i].y;
//判断是否合法（是否越界 是否是障碍物）
if (IsOk(point))
{
Node n = new Node(point,node);
if (i > 3)
{
n.G = node.G + 14;
}
else
{
n.G = node.G + 10;
}
n.CalculateH(end);
n.CalculateF();
list.Add(n);
if (point==end)
{
Debug.Log("Find!" );
Node p = n;//取出目标点
while (p != null )
{
//原路返回 将路径点放到List数组中
path.Push( new Vector2 (p.x, p.y));
p = p.Parent;
}
return;
}
}
}
}
}
void CreateMap()
{
GameObject Black = Resources .Load("Black") as GameObject ;
GameObject Red = Resources .Load("Red") as GameObject ;
GameObject Blue = Resources .Load("Blue") as GameObject ;
for (int i = 0; i < mapData.GetLength(0); i++)
{
for (int j = 0; j < mapData.GetLength(1); j++)
{
GameObject cube = null ;
switch (mapData[i, j])
{
case 1:
cube = GameObject.CreatePrimitive(PrimitiveType .Cube);
break;
case 2:
cube = GameObject.Instantiate(Black);
break;
case 9:
cube = GameObject.Instantiate(Blue);
break;
case 0:
cube = GameObject.Instantiate(Red);
break;
default:
break;
}
cube.transform.SetParent(transform);
cube.transform.position = GetPosition(i, j);
//cube.transform.position = new Vector3(i, 0, j);
cube.transform.localScale = Vector3.one* 0.95f;
}
}
}
#endregion
}
另一个脚本：Node类
using UnityEngine;
using System.Collections;
/// <summary>
/// 节点模型类
/// </summary>
public class Node {
//坐标
public int x, y;
//记录消耗值
public int F, G, H;
//父节点
public Node Parent;
//自动估算出H值，估计值
public void CalculateH(Vector2 end)
{
this.H = (int )(10 * (Mathf.Abs(end.x - x) + Mathf.Abs(end.y - y)));
}
//自动估算F值
public void CalculateF()
{
this.F = G + H;
}
public Node( int x,int y,Node parent= null)
{
this.x = x;
this.y = y;
this.Parent = parent;
}
public Node( Vector2 point, Node parent = null)
{
this.x = (int )point.x;
this.y =(int )point.y;
this.Parent = parent;
}
}
二叉树作者： 1056923207@qq.com |
class Node
{
public object Data;
public Node Left;
public Node Right;
}
class Program
{
static void Main(string[] args)
{
Node node = BuildTree(7);
TraverseTree(node);
}
/// <summary>
/// 递归先序遍历二叉树
/// </summary>
public static void TraverseTree( Node node)
{
if (node==null )
{
return;
}
Console.WriteLine(node.Data);
TraverseTree(node.Left);
TraverseTree(node.Right);
}
public static Node BuildTree( int rank)
{
Node root = new Node();
root.Data = 1;
Queue<Node > queue = new Queue< Node>();
queue.Enqueue(root);
int count = 1;
while (count<rank)
{
count++;
Node child = new Node();
child.Data = count;
queue.Enqueue(child);
Node point = queue.Peek();
if (point.Left == null )
{
point.Left = child;
}
else
{
point.Right = child;
queue.Dequeue(); //出队列
}
}
return root;
}
遍历二叉树递归非递归来源网址： http://blog.csdn.net/a497785609/article/details/4593224作者： 1056923207@qq.com |
递归实现先序中序后序遍历二叉树：
- //先序遍历
- static void PreOrder<T>(nodes<T> rootNode)
- {
- if(rootNode !=null )
- {
- Console.WriteLine(rootNode.Data);
- PreOrder <T>(rootNode.LNode );
- PreOrder <T>(rootNode.RNode);
- }
- }
- //中序遍历二叉树
- static void MidOrder<T>(nodes<T> rootNode)
- {
- if (rootNode != null)
- {
- MidOrder<T>(rootNode.LNode);
- Console.WriteLine(rootNode.Data);
- MidOrder<T>(rootNode.RNode);
- }
- }
- //后序遍历二叉树
- static void AfterOrder<T>(nodes<T> rootNode)
- {
- if (rootNode != null)
- {
- AfterOrder<T>(rootNode.LNode);
- AfterOrder<T>(rootNode.RNode);
- Console.WriteLine(rootNode.Data);
- }
- }
时间复杂度和空间复杂度作者： 1056923207@qq.com |
快速排序用来处理大量数据；
时间复杂度用o表示
一层循环：O(n)；
二层循环：O(n2);冒泡排序
快排时间复杂度：O(n*Logn)
宽度优选寻路算法（BFS）作者： 1056923207@qq.com |
using UnityEngine;
using System.Collections.Generic;
using System.Text;
using System.IO;
public class Map : MonoBehaviour
{
byte[,] data = new byte [5,5];
void Start()
{
LoadMapData();
BFSTest();
}
Queue< Vector2> queue = new Queue< Vector2>();
//存放已经访过的点
List< Vector2> visited = new List< Vector2>();
Vector2[] dirs = new Vector2 [] { Vector2.up, Vector2.right, Vector2 .down, Vector2.left };
void BFSTest()
{
//起始点
Vector2 start = Vector2 .zero;
//起始点进入未访问队列
queue.Enqueue(start);
//终止点
Vector2 end = Vector2 .one * 4;
//只要有点可以访问，就继续
while (queue.Count>0)
{
//访问一个点
Vector2 currentPoint = queue.Dequeue();
//标记该点已经访问过
visited.Add(currentPoint);
//访问前后左右
for (int i = 0; i < dirs.Length; i++)
{
Vector2 point;
point.x = currentPoint.x + dirs[i].x;
point.y = currentPoint.y + dirs[i].y;
if (IsOk(point))
{
queue.Enqueue(point);
if (point.x==end.x&&point.y==end.y)
{
Debug.Log("Find!" );
return;
}
}
}
}
Debug.Log("Can't Find!" );
}
//标记是否已经访问过
bool IsOk( Vector2 point)
{
if (point.x<0||point.y<0||point.x>4||point.y>4)
{
return false ;
}
if (data[(int )point.x,(int)point.y]==2) //=2代表是障碍物，不能访问 返回false
{
return false ;
}
//已经访问过
foreach (Vector2 item in visited)
{
if (item.x==point.x&&item.y==point.y)//已经访问过的元素存入visited文件中
{
return false ;
}
}
return true ;
}
void LoadMapData()
{
string path = Application .dataPath + "/Map/Map1.txt";
//文件读写流
StreamReader sr = new StreamReader(path); //用来读写文件
//读取内容
string result = sr.ReadToEnd();
//逐行截取
string[] data = result.Split(new char[] { '\n' });
for (int i = 0; i < 5; i++)
{
for (int j = 0; j < 5; j++)
{
this.data[i, j] = byte .Parse(data[i][j].ToString());
}
}
}
}
编辑器扩展作者： 1056923207@qq.com |
[MenuItem("GameObject/Transform/Position")]
Static void Created()
{
}
点击Position会触发
实例：
using UnityEngine;
using System.Collections;
using UnityEditor;
using System.IO;
using System.Text;
public class MapBuilder : Editor{
public const int RowCount = 20;
public const int ColCount = 20;
[MenuItem( "Map/Build")]
static void BuildMap()
{
//创建地图10*10
//规则：蓝色是海洋，红色是障碍物，黄色是终止点
byte[,] map = GetMapData();
GameObject Roads = new GameObject( "Roads");
GameObject BlueCube = Resources .Load("Blue") as GameObject ;
GameObject RedCude = Resources .Load("Red") as GameObject ;
for (int i = 0; i <RowCount; i++)
{
for (int j = 0; j < ColCount; j++)
{
switch (map[i,j])
{
case 1:
GameObject RCube= Instantiate(RedCude) as GameObject;
RCube.transform.SetParent(Roads.transform);
RCube.transform.position = new Vector3 (-17.5f + i, 0, j + 17.5f );
RCube.transform.localScale = Vector3.one * 0.8f;
RCube.name = i.ToString() + "_" + j.ToString();
break;
case 2:
GameObject Bcube= Instantiate(BlueCube) as GameObject;
Bcube.transform.SetParent(Roads.transform);
Bcube.transform.position = new Vector3 (-17.5f + i, 0, j + 17.5f );
Bcube.transform.localScale = Vector3.one * 0.8f;
Bcube.name = i.ToString() + "_" + j.ToString();
break;
default:
GameObject cube= GameObject .CreatePrimitive(PrimitiveType.Cube);
cube.transform.SetParent(Roads.transform);
cube.transform.position = new Vector3 (-17.5f + i, 0, j + 17.5f);
cube.transform.localScale = Vector3.one * 0.8f;
cube.name = i.ToString() + "_" + j.ToString();
break;
}
}
}
}
[MenuItem( "Map/Test")]
static byte[,] GetMapData()
{
string path = Application .dataPath + "/Map/Map1.txt";
//文件读写流
StreamReader sr = new StreamReader(path); //读取文件并且将文件中的内容放到sr中
string result = sr.ReadToEnd(); //读取内容(从当前位置到末尾读取)
string[] data = result.Split(new char[] { '\n'});//逐行截取,生成的数据就是一行一行的
byte[,] mapdata = new byte[RowCount, ColCount]; //定义一个二维数组
Debug.Log(data.Length);
for (int i = 0; i < RowCount; i++)
{
for (int j = 0; j < ColCount; j++)
{
mapdata[i, j] = byte.Parse(data[i][j].ToString());//将字符串存入到二维数组
}
}
return mapdata;
}
[MenuItem( "Map/CreateMap")]
static void CreateMap()
{
//第一步访问txt文件
string path = Application .dataPath + "/Map/Map1.txt";
FileStream fs= File .OpenWrite(path);//可以对文件进行操作
//第二步填充内容
StringBuilder sb = new StringBuilder(); //容量可变的字符串数组
for (int i = 0; i < RowCount; i++)
{
for (int j = 0; j < ColCount; j++)
{
sb.Append( Random.Range(0, 3));//给字符串添加值
}
sb.AppendLine(); //换行
}
byte[] map = Encoding .UTF8.GetBytes(sb.ToString());//想得到什么类型的数据就Get什么
fs.Write(map, 0, map.Length); //将字符写到map中，从map的第0个空间开始，长度为length
fs.Close(); //关闭流
fs.Dispose(); //释放资源
}
}
FileStream类来源网址： http://www.jb51.net/article/45696.htm作者： 1056923207@qq.com |
对流进行操作时要引用 using System.IO; 命名空间
FileStream常用的属性和方法：
属性：
CanRead 判断当前流是否支持读取，返回bool值，True表示可以读取
CanWrite 判断当前流是否支持写入，返回bool值，True表示可以写入
方法：
Read() 从流中读取数据，返回字节数组
Write() 将字节块（字节数组）写入该流
Seek() 设置文件读取或写入的起始位置
Flush() 清除该流缓冲区，使得所有缓冲的数据都被写入到文件中
Close() 关闭当前流并释放与之相关联的所有系统资源
文件的访问方式：（FileAccess）
包括三个枚举：
FileAccess.Read（对文件读访问）
FileAccess.Write（对文件进行写操作）
FileAccess.ReadWrite（对文件读或写操作）
文件打开模式：（FileMode）包括6个枚举
FileMode.Append 打开现有文件准备向文件追加数据，只能同FileAccess.Write一起使用
FileMode.Create 指示操作系统应创建新文件，如果文件已经存在，它将被覆盖
FileMode.CreateNew 指示操作系统应创建新文件，如果文件已经存在，将引发异常
FileMode.Open 指示操作系统应打开现有文件，打开的能力取决于FileAccess所指定的值
FileMode.OpenOrCreate 指示操作系统应打开文件，如果文件不存在则创建新文件
FileMode.Truncate 指示操作系统应打开现有文件，并且清空文件内容
文件共享方式：（FileShare）
FileShare方式是为了避免几个程序同时访问同一个文件会造成异常的情况。
文件共享方式包括四个：
FileShare.None 谢绝共享当前文件
FileShare.Read 充许别的程序读取当前文件
FileShare.Write 充许别的程序写当前文件
FileShare.ReadWrite 充许别的程序读写当前文件
使用FileStream类创建文件流对象：
FileStream（String 文件路径，FileMode 文件打开模式）
FileStream（String 文件路径，FileMode 文件打开模式，FileAccess 文件访问方式）
FileStream（String 文件路径，FileMode 文件打开模式，FileAccess 文件访问方式，FileShare 文件共享方式）
例：
//在C盘创建a.txt文件，使用fs流对象对文件进行操作，fs的工作模式是新建（FileMode.Create）
FileStream fs=new FileStream(@"c:\a.txt",FileMode.Create);
//在C盘创建a.txt文件，使用fs流对象对文件进行操作，fs工作模式是新建（FileMode.Create）文件的访问模式是写入（Fileaccess.Write）
FileStream fs=new FileStream(@"c:\a.txt",FileMode.Create,FileAccess.Write);
//在C盘创建a.txt文件，使用fs流对象对文件进行操作，fs工作模式是新建（FileMode.Create）文件的访问模式是写入（FileAccess.Write）文件的共享模式是谢绝共享（FileShare.None）
FileStream fs=new FileStream(@"c:\a.txt",FileMode.Create,FileAccess.Write,FileShare.None);
使用File类来创建对象：(常用)
自定义打开文件的方式：File.Open(String，FileMode);
打开文件进行读取： File.OpenRead(String);
打开文件进行写入： File.OpenWrite(String);
示例如下：
//在C盘新建123.txt文件，使用流对象fs对文件进行操作，fs可以行文件内容追加操作FileMode.Append
FileStream fs=File.Open(@"c:\123.txt",FileMode.Append);
//在C盘新建123.txt文件，使用流对象fs对文件进行操作，fs可以进行读文件File.OpenRead()
FileStream fs=File.OpenRead(@"c:\123.txt");
//在C盘新建123.txt文件，使用流对象fs对文件进行操作，fs可以进行写操作File.OpenWrite()
FileStream fs=File.OpenWrite(@"c:\123.txt");
使用File例：
对文件进行读操作：
//新建fs流对象对象产生的路径是textbox1.text的值，文件的模式是FileMode.OpenOrCreate(可读可写)
using (FileStream fs = File.Open(textBox1.Text, FileMode.OpenOrCreate))
{
//新建字节型数组，数组的长度是fs文件对象的长度（后面用于存放文件）
byte[] bt=new byte[fs.Length];
//通过fs对象的Read方法bt得到了fs对象流中的内容
fs.Read(bt,0,bt.Length);
//关闭fs流对象
fs.Close();
//将bt字节型数组中的数据由Encoding.Default.GetString(bt)方法取出，交给textbox2.text
textBox2.Text = System.Text.Encoding.Default.GetString(bt);
}
对文件进行写入操作：
//新建fs流对象，对象操作的文件路径在textbox1.text中，fs的操作模式是FileMode.Create
using (FileStream fs = File.Open(textBox1.Text, FileMode.Create))
{
//新建字节型数组bt对象，bt对象得到了textbox2.text的Encoding的值
byte[] bt = System.Text.Encoding.Default.GetBytes(textBox2.Text);
//将bt字节型数组对象的值写入到fs流对象中（文件）
fs.Write(bt,0,bt.Length);
//关闭流对象
fs.Close();
}
注：
对文件的读写操多不管代码有多少，无非就是下面的三步：
1.创建文件读写流对象
2.对文件进行读写
3.关闭文件流
摄像头相关知识来源网址： http://forum.china.unity3d.com/thread-622-1-1.html作者： 1056923207@qq.com |
using UnityEngine;
using System.Collections;
using UnityEngine.UI;
public class ExternalCamera : MonoBehaviour
{
public static ExternalCamera _instance;
public WebCamTexture cameraTexture;//摄像头照到的图片
private Image img;
void Awake()
{
_instance = this;
img = GetComponentInChildren< Image>();//获取子物体的组件
}
void Start()
{
StartCoroutine(CallCamera()); //开启携程
}
IEnumerator CallCamera()
{
yield return Application.RequestUserAuthorization( UserAuthorization.WebCam);//获取yoghurt摄像头权限
if (Application .HasUserAuthorization(UserAuthorization.WebCam)) //如果拥有摄像头权限
{
if (cameraTexture != null )//纹理存在
cameraTexture.Stop(); //
WebCamDevice[] device = WebCamTexture .devices;//将手机的两个摄像头存到数组
//找出后置摄像头 并且记录下它的名字
int index = 0;
for (int i = 0; i < device.Length; i++)
{
if (!device[i].isFrontFacing)//如果是后置摄像头
{
index = i;
break;
}
}
string deviceName = device[index].name;//获取后置摄像头的名字
cameraTexture = new WebCamTexture (deviceName);//纹理使用后置摄像头的额纹理
img.canvasRenderer.SetTexture(cameraTexture); //图片的纹理
cameraTexture.Play(); //启用该纹理
}
}
}
WebCamTexture（摄像机开发需要用到的类）[复制链接] |
|
扫雷游戏作者： 1056923207@qq.com |
using UnityEngine;
using System.Collections;
using UnityEngine.EventSystems;
using UnityEngine.UI;
/// <summary>
/// 格子类
/// </summary>
public class Grid
{
public bool IsLei;//是否是雷
public bool IsClicked;//是否点击了
public byte Count;//周围有几个雷
}
public class Map : MonoBehaviour, IPointerClickHandler//继承点击事件的接口函数
{
#region 常量
public const int RowCount = 10;//行数
public const int ColCount = 10;//列数
#endregion
#region 字段
private Grid[,] grids = new Grid[RowCount, ColCount]; //存储格子的数组
private GameObject[,] tiles = new GameObject[RowCount, ColCount]; //存储预设体实例化对象的的数组
private Vector2[] dirs = new Vector2[] { Vector2.up, Vector2 .down, Vector2.left, Vector2.right, new Vector2(-1, 1), new Vector2(-1, -1), new Vector2 (1, 1), new Vector2(1, -1) }; //格子周围八个方块
[SerializeField]
private Transform gridContainer;
[SerializeField]
private GameObject gridPrefab;
#endregion
#region 方法
//初始化游戏
public void StartGame()
{
for (int i = 0; i < RowCount; i++)
{
for (int j = 0; j < ColCount; j++)
{
//注意两个数组的坐标是一致的
//下面两句主要是给格子初始化，那些有雷，那些没有雷
grids[i, j] = new Grid ();//初始化格子
grids[i, j].IsLei = Random.Range(1, 11) > 2 ? false : true;//是否是雷
GameObject grid = (GameObject )Instantiate(gridPrefab);//创建格子
grid.transform.SetParent(gridContainer); //放到格子中
grid.name = i.ToString() + "_" + j.ToString();//格子的名字就是xy坐标中间加"_";便于后面运算
tiles[i, j] = grid; //将实例化出来的button放到数组中
}
}
}
/// <summary>
/// 格子点击
/// </summary>
/// <param name="x"> The x coordinate.</param>
/// <param name="y"> The y coordinate.</param>
public void GridClick(int x, int y)
{
if (!grids[x, y].IsClicked)
{ //如果格子没有点击过
grids[x, y].IsClicked = true;
if (grids[x, y].IsLei)
{
print( "输了");
return;
}
for (int i = 0; i < dirs.Length; i++)
{
int temp_x = x + (int )dirs[i].x;
int temp_y = y + (int )dirs[i].y;
//判断是否越界
if (temp_x >= 0 && temp_x < RowCount && temp_y >= 0 && temp_y < ColCount)
{
if (grids[temp_x, temp_y].IsLei)
{
grids[x, y].Count++; //当前格子周围的雷数+1
}
}
}
tiles[x, y].transform.GetChild(0).gameObject.SetActive( true);//把Text脚本激活用来显示雷数
tiles[x, y].GetComponent< Image>().color = Color .gray;//改变颜色
if (grids[x, y].Count > 0)
{
// Debug.Log("Click");
tiles[x, y].GetComponentInChildren< Text>().text = grids[x, y].Count.ToString();
}
else
{
DiGui(x, y);
}
}
}
/// <summary>
/// 递归
/// </summary>
/// <param name="x"> The x coordinate.</param>
/// <param name="y"> The y coordinate.</param>
public void DiGui(int x, int y)
{
for (int i = 0; i < dirs.Length; i++)
{
int temp_x = x + (int )dirs[i].x;
int temp_y = y + (int )dirs[i].y;
//判断是否越界
if (temp_x > 0 && temp_x < RowCount && temp_y > 0 && temp_y < ColCount)
{
GridClick(temp_x, temp_y);
}
}
}
#endregion
void Start()
{
StartGame();
}
//鼠标点击格子触发函数
public void OnPointerClick(PointerEventData eventData)
{
// Debug.Log("LLL");
GameObject enter = eventData.pointerEnter;
//如果是格子
Debug.Log(enter.name);
if (enter.name.Contains("_" ))
{
int x = int .Parse(enter.name.Split('_')[0]);
int y = int .Parse(enter.name.Split('_')[1]);
GridClick(x, y);
Debug.Log("LLL" );
}
}
}
递归作者： 1056923207@qq.com |
先调用和先打印书序反了结果也会反；
屏幕坐标转世界坐标（好用）来源网址： http://www.tuicool.com/articles/Rjiqeq作者： 1056923207@qq.com |
using UnityEngine;
using System.Collections;
public class CubeTest : MonoBehaviour {
void Update () {
Vector3 Screen_point = Input .mousePosition;
Screen_point += new Vector3 (0, 0, transform.position.z - Camera.main.transform.position.z);
transform.position = Camera.main.ScreenToWorldPoint(Screen_point);
// Debug.Log(transform.position);
}
}
摄像机坐标系：0到1
屏幕坐标是：
unity3d中的屏幕坐标系 是以 屏幕 左下角为（0,0）点 右上角为（Screen.Width,Screen.Height)
鼠标位置坐标与屏幕坐标系一致
视口坐标是以摄像机为准 以屏幕的左下角为（0,0）点 右上角为（1,1）点
绘制GUI界面时使用的坐标是以 屏幕 的左上角为（0，0）点 右下角为（Screen.width,Screen,Height)
经常会用到 某个物体的世界坐标到屏幕坐标的转化然后再屏幕上绘制出这个物体的代表性图片
是这样做的
1、Vector3 ScreenPos=Camera.WorldToScreenPoint(trans.Position);
2、GUIPos=new Vector3(ScreenPos.x,Screen.height-ScreenPos.y,0);
然后按照这个坐标绘制图片就可以了
网络相关知识作者： 1056923207@qq.com |
1：引入命名空间 Using system.Net和using System.Net.Sockets;
2:服务器代码；
Socket mConn = new Socket(AddressFamily.InterNetWork, SocketType.Stream, ProtocoType.Tcp);
int Port = 7777;
IPEndPoint endpoint = new IPEndPoint(IPAddress.Any, Port);
mConn.Bind(endpoint);
mConn.Listen(10);
a:同步接收客户端的代码（在当前客户端没有连接之前，不能进行其他操作 只能等着）
while (true)
{
Socket client = mConn.Accept();
Console.WriteLine("有客户端连接");
}
b:异步接收客户端代码
mConn.BeginAccept(AcceptClient,mConn)
Console.ReadLine();//（这个方法也是相当于同步方法）保持服务器一直开着，
private static void AcceptClient(IAsyncResult ar)
{
Console.WriteLine("有客户端连接");
Socket server= ar。AsyncState as Socket;
Socket client = server.EndAccept(ar);
Console.WriteLine(client.RemoteEndPoint);//打印连接的客户端的IP地址
//再次开启异步接收
server.BeginAccept（AcceptCllient,server）;
}
客户端代码：
using UnityEngine;
using System.Collections;
using UnityEngine.Networking;
using System.Net;
using System.Net.Sockets;
public static class MyNetWork
{
private static Socket mConn;
/// <summary>
/// 开启服务器
/// </summary>
// public static void StartServer(int port = 7777)
// {
// mConn = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);//Tcp可靠，Udp不可靠
//Http Https Http不加密 传输速度快 不安全 HTTPS加密
// IPEndPoint endpoinnt = new IPEndPoint(IPAddress.Any, port);
// mConn.Bind(endpoinnt);//看似器服务器之前必须绑定IP和端口
// mConn.Listen(11);
// }
/// <summary>
/// 开启客户端
/// </summary>
/// <param name="endPoint"></param>
public static void StartClient(IPEndPoint endPoint)
{
mConn = new Socket (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType .Tcp);
mConn.Connect(endPoint);
Debug.Log(mConn.Connected);
}
}
3：客户端调用方法
using UnityEngine;
using System.Collections;
using System.Net.Sockets;
using System.Net;
public class Testtt : MonoBehaviour {
void Start () {
// MyNetWork.StartServer();
//IPAddress ipaddress = IPAddress.Parse("172.18.21.139");
IPAddress ipaddress = IPAddress .Parse("127.0.0.1");
int port = 7777;
IPEndPoint endpoint = new IPEndPoint(ipaddress,port);
MyNetWork.StartClient(endpoint);
Debug.Log("链接服务器成功" );
}
}
异步加载场景作者： 1056923207@qq.com |
1：第一个场景Button上挂载的脚本 要加载滴二哥场景
using UnityEngine;
using System.Collections;
using UnityEngine.UI;
public class Test : MonoBehaviour {
void Start()
{
GetComponent< Button>().onClick.AddListener(LoadScene);
}
public void LoadScene()
{
LoadingManager.Instance.LoadScene("2" );
}
}
2：单例类加载管理器
using UnityEngine;
using System.Collections;
using UnityEngine.SceneManagement;
public class LoadingManager {
#region 属性
public static LoadingManager instace;
private AsyncOperation mAsync;
private string scenename;
public string Name
{
get
{
return scenename;
}
}
public static LoadingManager Instance
{
get {
if (instace==null )
{
instace = new LoadingManager ();
}
return instace;
}
}
#endregion
#region 方法
public void LoadScene(string SceneName)
{
SceneManager.LoadScene("Login" );
//（同步方法）场景名字加载场景
//mAsync = SceneManager.LoadSceneAsync(SceneName);
// mAsync.allowSceneActivation =false;
this.scenename = SceneName;
}
3：Login场景中的脚本
using UnityEngine;
using System.Collections;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
public class Loading : MonoBehaviour {
private AsyncOperation mAsync=null ;//异步加载场景的返回值
private string targetScene;
private int mProgress = 0;//表示当前进度
private int mCurrent = 0;//表示实际进度
private Slider mSlider;//进度条
void Awake()
{
mSlider = GetComponent< Slider>();
}
void Start ()
{
targetScene = LoadingManager.Instance.Name;
mAsync = SceneManager.LoadSceneAsync(targetScene);
mAsync.allowSceneActivation = false;
//print(LoadingManager.Instance.Name);
}
void Update()
{
mCurrent = System. Convert.ToInt32(mAsync.progress * 100);
if (mCurrent==90)
{
mProgress = 100;
}
if (mProgress == 100)//表示进度完成
{
mAsync.allowSceneActivation = true;
}
else
{
if (mProgress<mCurrent)
{
mProgress++;
mSlider.value = mProgress / 10000f;
}
}
print(mAsync.progress);
}
}
#endregion
}
SDK/Json作者： 1056923207@qq.com |
1：分享功能：
第一个脚本：取到Json字符串；
using UnityEngine;
using System.Collections;
using System.Net;
using System.IO;
using LitJson;
public class HttpUtility
{
/// <summary>
/// Get请求，获取内容
/// </summary>
/// <param name="url"> 网址</param>
public static string GetHttpText(string url)
{
//创建一个Http请求对象
HttpWebRequest request = HttpWebRequest .Create(url) as HttpWebRequest;
//获取相应对象
WebResponse response = request.GetResponse();
//获取相应的内容
Stream steam = response.GetResponseStream();
StreamReader sr = new StreamReader(steam);
string result = sr.ReadToEnd();
sr.Close();
sr.Dispose();
return result;
//WWW www = new WWW(url);
//while (!www.isDone)
//{
//}
//string result = www.text;
//return result;
}
//public static T GetHttpText<T>(string url) where T:class
//{
// //创建一个Http请求对象
// HttpWebRequest request = HttpWebRequest.Create(url) as HttpWebRequest;
// //获取相应对象
// WebResponse response = request.GetResponse();
// //获取相应的内容
// Stream steam = response.GetResponseStream();
// StreamReader sr = new StreamReader(steam);
// T result = sr.ReadToEnd() as T;
// sr.Close();
// sr.Dispose();
// return result;
// //WWW www = new WWW(url);
// //while (!www.isDone)
// //{
// //}
// //string result = www.text;
// //return result;
//}
//public static Weatherdata SetWeatherData(string jsonData)
//{
// try
// {
// return JsonMapper.ToObject<Weatherdata>(jsonData);
// }
// catch (System.Exception ex)
// {
// UnityEngine.Debug.Log(ex.ToString());
// return null;
// }
//}
}
第二个脚本：根据Json字符串的格式定义一个接收Json转换成Object对象的数据结构
using UnityEngine;
using System.Collections;
[System.Serializable]
public class Weather
{
public string retCode; // 返回码
public string msg; // 返回说明
public WeatherData [] result;
}
[System.Serializable]
public class WeatherData
{
public string airCondition; // 空气质量
public string city; // 城市
public string coldIndex; // 感冒指数
public string updateTime; // 更新时间
public string date; // 日期
public string distrct; // 区县
public string dressingIndex; // 穿衣指数
public string exerciseIndex; // 运动指数
public Future [] future;
public string humidity; // 湿度
public string pollutionIndex; // 空气质量指数
public string province; // 省份
public string sunset; // 日落时间
public string sunrise; // 日出时间
public string temperature; // 温度
public string time; // 时间
public string washIndex; // 洗车指数
public string weather; // 天气
public string week; // 星期
public string wind; // 风向
}
[System.Serializable]
public class Future
{
public string date; // 日期
public string dayTime; // 白天天气
public string night; // 晚上天气
public string temperature; // 温度
public string week; // 星期
public string wind; // 风向
}
第三个脚本：测试脚本，将前两个脚本链接起来
using UnityEngine;
using System.Collections;
using LitJson;
public class Testt : MonoBehaviour {
// Use this for initialization
void Start () {
string result = HttpUtility .GetHttpText(Const.WeatherApiURL);
JsonData nn = JsonMapper .ToObject(result);
Weather kk = JsonMapper .ToObject<Weather>(result);
Debug.Log(kk.result[0].wind);
// Debug.Log(mm.result[0].future[0].date);
// Debug.Log(nn[0]);
//Debug.Log();
}
// Update is called once per frame
void Update ()
{
}
}
马帅的摄像机作者： 1056923207@qq.com |
DataBaseTool作者： 1056923207@qq.com |
/*******************
********************/
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using Mono.Data.Sqlite;
/// <summary>
/// 数据库操作的单例类
/// </summary>
public class DataBaseTool
{
private static DataBaseTool _instance;//单例的静态引用
public static DataBaseTool Instance
{
get
{
if (_instance == null )
{
_instance = new DataBaseTool ();
}
return _instance;
}
}
private string databaseName = "IslandDatabase.sqlite" ;//数据库名称
//数据库链接对象
private SqliteConnection sqlConnection = null ;
//数据结果
private SqliteDataReader sqlDataReader = null ;
/// <summary>
/// 初始化数据库相关对象
/// </summary>
private DataBaseTool()
{
//数据库链接地址
string path = "Data Source=" + Application.streamingAssetsPath + "/" + databaseName;
if (sqlConnection == null )
{
try
{
sqlConnection = new SqliteConnection (path);
}
catch (SqliteException e)
{
Debug.Log("创建数据库链接失败..." );
Debug.Log(e.ToString());
}
}
}
/// <summary>
/// 打开数据库链接
/// </summary>
private void OpenConnection()
{
if (sqlConnection != null )
{
try
{
sqlConnection.Open();
}
catch (SqliteException e)
{
Debug.Log("打开数据库链接失败..." );
Debug.Log(e.ToString());
}
}
else {
Debug.Log("打开数据库链接失败..." );
}
}
/// <summary>
/// 关闭数据库链接
/// </summary>
private void CloseConnection()
{
if (sqlConnection != null )
{
try
{
sqlConnection.Close();
}
catch (SqliteException e)
{
Debug.Log("关闭数据库链接失败..." );
Debug.Log(e.ToString());
}
}
else {
Debug.Log("关闭数据库链接失败..." );
}
}
/// <summary>
/// 执行增、删、改数据库操作
/// </summary>
public void ExcuteSql(string sqlStr)
{
OpenConnection();
SqliteCommand sqlCommand = sqlConnection.CreateCommand();
if (sqlCommand != null )
{
sqlCommand.CommandText = sqlStr;
int result = sqlCommand.ExecuteNonQuery();
}
else {
Debug.Log("执行数据库命令失败..." );
}
CloseConnection();
}
/// <summary>
/// 获得一行数据的方法
/// </summary>
public Dictionary<string , object> ExcuteOneClumeResult( string sql)
{
OpenConnection();
Dictionary<string , object> result = new Dictionary <string, object>();
SqliteCommand sqlCommand = sqlConnection.CreateCommand();
if (sqlCommand != null )
{
sqlCommand.CommandText = sql;
sqlDataReader = sqlCommand.ExecuteReader();
while (sqlDataReader.Read())
{
for (int i = 0; i < sqlDataReader.FieldCount; i++)
{
result.Add(sqlDataReader.GetName(i), sqlDataReader.GetValue(i));
}
break;
}
}
else {
result = null;
}
CloseConnection();
return result;
}
/// <summary>
/// 返回查询的所有数据（多列）
/// </summary>
/// <returns>The all rresult.</returns>
public List<Dictionary <string, object>> ExcuteAllRresult(string sql)
{
OpenConnection();
//存放查询的所有结果集
List<Dictionary <string, object>> results
= new List <Dictionary< string, object >>();
SqliteCommand sqlCommand = sqlConnection.CreateCommand();
if (sqlCommand != null )
{
//打包sql语句
sqlCommand.CommandText = sql;
//执行sql语句并获得查询结果
sqlDataReader = sqlCommand.ExecuteReader();
//逐行解析数据
while (sqlDataReader.Read())
{
//单行数据的所有内容
Dictionary<string , object> oneclum = new Dictionary <string, object>();
for (int i = 0; i < sqlDataReader.FieldCount; i++)
{
oneclum.Add(sqlDataReader.GetName(i), sqlDataReader.GetValue(i));
}
results.Add(oneclum);
}
}
CloseConnection();
return results;
}
}
泛型单例父类作者： 1056923207@qq.com |
using UnityEngine;
using System.Collections;
public abstract class MonoSingle< T> : MonoBehaviour where T :MonoBehaviour
{
private static T instance;
public static T Instance
{
get
{
return instance;
}
}
public virtual void Awake()
{
instance = this as T;
}
}
这个单例父类的作用就是当有多个类需要写成单例是，不用重复写单例；
@其他的类继承这个类就可以当做单例使用，例如下例：（注意继承的方式）
using UnityEngine;
using System.Collections;
/// <summary>
/// 声音控制器,单例类
/// </summary>
public class SoundController : MonoSingle<SoundController >
{
AudioSource m_bgMusic;
public override void Awake()
{
base.Awake();//继承基类的方法
m_bgMusic = gameObject.AddComponent< AudioSource>();//获取AudioSource组件
m_bgMusic.loop = true;//循环播放
m_bgMusic.playOnAwake = false;
}
//播放背景音乐
public void PlayBG(string bgName)
{
string currentBgName = string .Empty;//定义一个空的string类型变量
if (m_bgMusic !=null )//如果存在AudioSoruce组件
{
currentBgName = m_bgMusic.name; //获取组件的名字
}
if (bgName == currentBgName)
{
return;//如果传进来的生意与原来的声音一样 就不用重新开始播放啦
Debug.Log("------" );
}
AudioClip clip = Resources .Load<AudioClip>(bgName); //加载声音资源
if (clip!=null )//如果存在声音资源
{
m_bgMusic.clip = clip; //给声音组件赋值
m_bgMusic.Play(); //播放声音组件
}
}
/// <summary>
/// 播放特效音乐
/// </summary>
/// <param name="Effectname"></param>
public void PlayEffect(string Effectname,float volume = 1f)
{
AudioClip clip = Resources .Load<AudioClip>(Effectname); //加载声音资源
if (clip!=null )//如果声音资源不为空
{
AudioSource.PlayClipAtPoint(clip, transform.position);
}
}
}
关于AudioSource和AudioClip的使用作者： 1056923207@qq.com |
1：实例一个AudioSource的对象： AudioSource m_bgMusic;
2：实例化一个AudioClip的对象，并且赋一个值：AudioClip clip = Resources .Load<AudioClip>(bgName);
3：m_bgMusic.clip = clip; //给声音组件赋值
4： m_bgMusic.Play(); //播放声音组件
using UnityEngine;
using System.Collections;
/// <summary>
/// 声音控制器,单例类
/// </summary>
public class SoundController : MonoSingle<SoundController >
{
AudioSource m_bgMusic;
public override void Awake()
{
base.Awake();//继承基类的方法
m_bgMusic = gameObject.AddComponent< AudioSource>();//获取AudioSource组件
m_bgMusic.loop = true;//循环播放
m_bgMusic.playOnAwake = false;
}
//播放背景音乐
public void PlayBG(string bgName)
{
string currentBgName = string .Empty;//定义一个空的string类型变量
if (m_bgMusic !=null )//如果存在AudioSoruce组件
{
currentBgName = m_bgMusic.name; //获取组件的名字
}
if (bgName == currentBgName)
{
return;//如果传进来的生意与原来的声音一样 就不用重新开始播放啦
Debug.Log("------" );
}
AudioClip clip = Resources .Load<AudioClip>(bgName); //加载声音资源
if (clip!=null )//如果存在声音资源
{
m_bgMusic.clip = clip; //给声音组件赋值
m_bgMusic.Play(); //播放声音组件
}
}
/// <summary>
/// 播放特效音乐
/// </summary>
/// <param name="Effectname"></param>
public void PlayEffect(string Effectname,float volume = 1f)
{
AudioClip clip = Resources .Load<AudioClip>(Effectname); //加载声音资源
if (clip!=null )//如果声音资源不为空
{
AudioSource.PlayClipAtPoint(clip, transform.position);
}
}
}
类可以继承 结构体不能继承；作者： 1056923207@qq.com |
类可以继承 结构体不能继承；
接口和抽象类的区别：接口不能被实现，只能声明
动画插件Itween和dotween作者： 1056923207@qq.com |
自己定义的MyTween脚本：
using UnityEngine;
using System.Collections;
public class MyTween : MonoBehaviour
{
#region 字段
public Vector3 position;
public float time, delay;
public LoopType looptype;
public EaseType easetype;
#endregion
#region 枚举
public enum LoopType
{
Once,
Loop,
Pingppang
}
public enum EaseType
{
Liner,
Spring
}
#endregion
#region 注册方法
public static void MoveTo(GameObject go, Hashtable args)
{
MyTween tween = go.AddComponent<MyTween >();
if (args.Contains("position" ))
{
tween.position =( Vector3)args["position" ];
}
if (args.Contains("time" ))
{
tween.time = ( float)args["time" ];
}
if (args.Contains("delay" ))
{
tween.delay = ( float)args["delay" ];
}
if (args.ContainsKey("loopType" ))
{
tween.looptype = ( LoopType)System.Enum .Parse(typeof( LoopType), args["loopType" ].ToString());//字符串强转成枚举得方法
}
}
#endregion
#region 方法
private float timer;
void MoveTo()
{
timer += Time.deltaTime;//计时
if (timer>delay)
{
//如果是平滑移动，保持起始点和终点不变 只有时间边
//如果是先快后慢，保证时间和终点不变，起始点变化
//Lerp公式：from +(to -from)*time,time= [0,1]
transform.position = Vector3.Lerp(transform.position, position, (timer - delay)/time);
}
if (timer>delay+time)//一段时间后销毁本脚本
{
if (looptype==LoopType .Once)//如果循环的类型为单次
{
Destroy( this);
}
}
}
#endregion
void Update()
{
Invoke( "MoveTo",0f);
}
}
调用MyItween的Test脚本：
using UnityEngine;
using System.Collections;
public class Test : MonoBehaviour {
Hashtable har;
// Use this for initialization
void Start () {
//是一个集合(哈希表)，可以存储任意类型
har = new Hashtable();
har.Add( "amount", Vector3 .one*180);
har.Add( "position", Vector3 .one * 3);
har.Add( "time", 5f);
// har.Add("Time", 3f);
har.Add( "delay", 1f);
har.Add( "loopType", MyTween .LoopType.Once);
har.Add( "easeType", MyTween .EaseType.Liner);
har.Add( "rotation", Vector3 .up * 180);
// iTween.RotateTo(gameObject, har);
//iTween.ShakePosition(gameObject, har);
//iTween.ShakeRotation(gameObject,har);
MyTween.MoveTo(gameObject, har);
}
// Update is called once per frame
void Update () {
// iTween.MoveUpdate(gameObject, har);
}
}
调用的Test脚本
using UnityEngine;
using System.Collections;
public class Test : MonoBehaviour {
Hashtable har;
// Use this for initialization
void Start ()
{
//是一个集合(哈希表)，可以存储任意类型
har = new Hashtable ();
har.Add( "amount", Vector3 .one*180);
har.Add( "position", Vector3 .one * 3);
har.Add( "time", 5f);
// har.Add("Time", 3f);
har.Add( "delay", 1f);
har.Add( "loopType", MyTween .LoopType.Once);
har.Add( "easeType", MyTween .EaseType.Liner);
har.Add( "rotation", Vector3 .up * 180);
// iTween.RotateTo(gameObject, har);
//iTween.ShakePosition(gameObject, har);
//iTween.ShakeRotation(gameObject,har);
MyTween.MoveTo(gameObject, har);//静态方法通过类名点调用；非静态方法通过对象调用
}
// Update is called once per frame
void Update () {
// iTween.MoveUpdate(gameObject, har);
}
}
关于技能的释放作者： 1056923207@qq.com |
1;从数据库英雄表取出数据 用逗号分割，存入string数组；
this.skillsname = heroData[ "Skills"].ToString().Split(',' );
2：将这些string类型的转成int类型，存入整形数组（容量大小与string类型的数组相同）；
3：根据这些id在数据结构里面初始化技能；mskills存储的是技能数据结构，因为这个脚本是在aunit里面 aunit在人物身上，所以有aunit脚本的就可以调用技能数据。在UIController里面添加对应英雄的aunit脚本就可以调用技能数据；
this.skillsname = heroData["Skills" ].ToString().Split(',');
mSkillsId = new int [skillsname.Length];
this.mSkills = new SkillData[skillsname.Length];
//初始化技能数据
for (int i = 0; i < skillsname.Length; i++)
{
mSkillsId[i] = int.Parse(skillsname[i]);
this.mSkills[i].InitSkillData(this .mSkillsId[i]);
}
跨脚本调用方法作者： 1056923207@qq.com |
如果方法是静态的 就通过类名（脚本名字）调用；
如果方不是静态的：就通过实例化对象 然后点的方法调用（方法必须是公有的才能点出来）
改变鼠标指针单例脚本，在其他脚本中可以调用作者： 1056923207@qq.com |
using UnityEngine;
using System.Collections;
using UnityEngine.UI;
public class NYBTest : MonoBehaviour
{
public static NYBTest _instance;
public Texture2D normal;
public Texture2D npc;
public Texture2D attack;
public Texture2D locktarget;
public Texture2D pick;
private Vector2 hotspot = Vector2 .zero;
private CursorMode mode = CursorMode .Auto;
void Start()
{
_instance = this;
}
public void SetNormal()
{
Cursor.SetCursor(normal, hotspot, mode);
}
public void NPC()
{
Cursor.SetCursor(npc, hotspot, mode);
}
}
xml写的Transform和Json作者： 1056923207@qq.com |
Json：
Json写的transform：
委托作者： 1056923207@qq.com |
委托是讲方法作为参数进行传递方法既可以是静态方法，又可以是实例方法
委托的声明圆形如下：
delegate <函数返回类型><委托名>(<函数参数>)
委托主要用来实现回调：
委托是的使用步骤
属性，数据类型，方法参数作者： 574096324@qq.com |
属性
classCar
{
private string brand;
public double price;
//get,set也称为属性
public string GetBrand()
{
return brand;
}
public void SetBrand(string c)
{
brand = c;
}
public double GetPrice()
{
return price;
}
public void SetPrice(double p)
{
price = p;
}
}
属性 简写
public double Price
{
get;
set;
}
数据类型
数据在内存中的空间分配
*栈区：值类型定义的变量 压栈，出栈
*堆区：数组，对象
常量区：常量
静态区：Main前面static，字段用static修饰在 静态区
代码区：方法
方法参数
新版网络作者： 1056923207@qq.com |
1;端口：每个端口对应一个服务
2：新版网络的API：
Unity 网络服务器：NetWorkServer
3dmax作者： 1056923207@qq.com |
3dmax
ps
ai
Leapmotion虚拟现实作者： 1056923207@qq.com |
1.下载Leapmotion SDK（https://developer.leapmotion.com/v2）
2.拖入到场景中
3.找到预设体的HandController拖到场景中 缩放调为10
4.运行游戏 笔记本有摄像头可以实现手部识别
5.核心的脚本就是HandController
Socket作者： 1056923207@qq.com |
步骤：服务器创建一个套接字。2：绑定一个端口 。3：监听 lister4：accept
两种协议：1.TCP(可靠的协议，例如qq)2.UDP（看视频）
Unity网络基本知识作者： 1056923207@qq.com |
1：网络通信协议
2：IP地址
NetWork类创建爱你服务器和客户端：
Unity高通AR解析步骤来源网址： http://www.jianshu.com/p/bb9aa8bf2225作者： 1056923207@qq.com |
下载简书移动应用
Unity高通AR解析（一）
字数852阅读2874评论7喜欢12
前言
在这个生活方式都日新月异的年代，任何的新技术产生都不足为奇，当然本篇所讲的AR（增强现实技术）也并不是最新的技术了，目前市面上已经很多AR方面的硬件设备，当然AR技术也日渐成熟。目前，Unity对AR的支持，只有一家——高通，原来还有一家Metaio被Apple收购要现在杳无音讯，暂且不提。高通(Qualcomm)是提供Unity插件开发AR产品的AR公司。本篇我们就来用高通的插件，来开发一个UnityAR小程序。想学Unity就来蓝鸥找我吧
- 注册高通账号，获取许可证，注册识别图
- 由于高通的AR技术是不开源的，所以使用的时候还需要注册许可证号。首先，我们登录高通官方网站。
高通AR官网 - 注册账号
注册
注册界面1（密码中字母要有大写有小写）
注册界面2
注册界面3
注册成功
邮箱验证 - 登录到高通
登录
登录成功 - 下载插件
下载插件 - 注册许可证
注册许可证
填写项目名称
完成许可证注册
查看注册好了的许可证 - 获取许可证号
获取许可证号，暂时保存起来，一会儿会用到 - 注册识别图数据库
注册识别图数据库
创建数据库
打开数据库创建识别图
添加识别图
添加识别图成功
下载数据
选择Unity Editor，下载
下载好了的Package - 准备就绪，开始Unity开发
- 创建工程，导入资源（本例使用Unity5.0.2）
创建工程
导入高通插件和刚刚生成的Logo包
导入成功
找到ARCamera预设体和TargetImage预设体，导入场景
删除MainCamera - ARCamera属性介绍
VuforiaBehaviour1.AppLicenseKey//App许可证号码 2.CameraDeviceMode//摄像机设备模式 MODE_DEFAULT = -1,//默认（默认） MODE_OPTIMIZE_SPEED = -2,//速度优化 MODE_OPTIMIZE_QUALITY = -3//质量优化 3.Max Simultaneous Tracked Images//最大跟踪图片数量 4.Max Simultaneous Tracked Objects//最大跟踪对象数量 5.Delayed Loading Object Data Sets//延迟加载对象数据集 6.Camera Direction//摄像机方向 CAMERA_DEFAULT,//默认（默认） CAMERA_BACK,//后面 CAMERA_FRONT//前面 7.Mirror Video Background//镜像视频背景 DEFAULT,//默认（默认） ON,//开启 OFF//关闭 8.World Center Mode//全球中心模式 SPECIFIC_TARGET,//特定的目标 FIRST_TARGET,//第一个目标 CAMERA//摄像机（默认） 9.Bind Alternate Camera//绑定替代相机 - 我们需要的设置
复制许可证号
写入许可证号
激活对象 - ImageTarget属性介绍
ImageTarget属性介绍1.Type类型 PREDEFINED,//预定义的（默认） USER_DEFINED,//用户定义的 CLOUD_RECO//云侦察的 2.Data Set//数据集 3.Image Target//目标识别图 4.Width//宽度 5.Height//高度 6.preserve child size//保存子对象大小 7.Extended Tracking//跟踪拓展 8.Smart Terrain//智能地形 - 我们需要的设置
选择数据库和识别图 - 找一个识别后显示的模型，放置为ImageTarget的子物体
放置模型 - 设置摄像机位置，调整模型缩放
微调 - 运行测试
我的iOS9.1，还没来得及下Xcode7.1，暂时这样测试结束语
本篇主要实现基本的AR显示，后续还会写后面的高级实现，敬请期待。想学Unity就来蓝鸥找我吧
如果觉得我的文章对您有用，请随意打赏。您的支持将鼓励我继续创作！
¥ 打赏支持
12
打开微信“扫一扫”，打开网页后点击屏幕右上角分享按钮
www作者： 1056923207@qq.com |
www的属性：texture（下载的图片） audioclip（下载的声音） movie（下载的视频） bytes（下载的二进制，把文件以二进制的形式存储下来） text isdone （是否下载完成 ）progress（下载的进度） URL（下载的地址）
整个代码所有名字为www的变量名字的改变：点击程序中任意一个变量名，然后右键重命名 这样改一个就可以，程序中所有其他的都会改变；
协程作者： 1056923207@qq.com |
携程的使用方法：
注意：携程的方法需要把void换成IEnumerator 然后在Start里面用startCoroutine()开启携程（该方法里面是携程的"方法名字”或者如下所示）
void Start()
{
StartCoroutine(DownLoadMovia());
}
public IEnumerator DownLoadMovia()
{
string url = "http://172.18.21.77/aaa.mp4";
WWW www = new WWW(url);
yield return www;
}
携程的方法：StartCoroutine(方法)；
StopCoroutine（方法）；
Yield return WaitForSeconds（float f）；//过f秒再执行后面的代码；
yield return StarCoroutine（otherIEnumerator（））；//等到括号里面的携程执行完毕后 在执行本句后面的代码；
携程的执行顺序 在Update和LateUpdate之间；
打包作者： 1056923207@qq.com |
数据库 发布到安卓：
两个路径1.当前工程数据库文件的位置
2安卓手机上程序的安装位置（因为；安卓里没有数据库文件。解决方案：放一个数据库文件进来）；
将数据库文件放置到安卓手机程序的安装位置；1
1： 解析安装包apk 拿到数据库文件 然后放置到安卓手机程序的安装位置
两个语法：
1：安装包apk路径语法 jar
2：安卓数据库链接字符串语法 url
发布到安卓的具体方法：
数据库登录界面作者： 1056923207@qq.com |
using UnityEngine;
using System.Collections;
using Mono.Data.Sqlite;
using UnityEngine.UI;
public class InputCheck : MonoBehaviour {
public InputField passwordtext;
// Use this for initialization
void Start () {
}
// Update is called once per frame
void Update () {
}
public void CheckUserName()
{
string datapath = "Data Source=" + Application .streamingAssetsPath + "/UserDatabase.sqlite" ;
SqliteConnection userconnect = new SqliteConnection (datapath);
userconnect.Open();
SqliteCommand usercommand = userconnect.CreateCommand();
string userstring = transform.GetComponent< InputField>().text;
usercommand.CommandText = "select * from UserTable";
SqliteDataReader username = usercommand.ExecuteReader();
while (username.Read())
{
for ( int i = 0; i < username.FieldCount; i++)
{
//返回值为object
//如果账号正确
if (username.GetValue(i).ToString() == userstring)
{
//判断密码是否正确
if (username.GetValue(1).ToString() == passwordtext.text)
{
Debug.Log( "登录成功" );
return;
}
//密码不正确
Debug.Log( "密码错误" );
return;
}
else
{
Debug.Log( "账号不存在" );
}
}
}
}
}
SQLite作者： 1056923207@qq.com |
sql语法：
数据库字符串类型的要用单引号引起来例如:'sadfas'
username.GetValue(i)；返回值为object类型：
示例
数据存储作者： 1056923207@qq.com |
xml的生成与解析：
1：xml的生成：（引入命名空间using System.Xml:xml的生成与解析都用这一个就行）
//生成xml文件
public void creatXML()
{
//生成xml文件的名称以及路径
string filepath = Application.dataPath + "/Resources/XMLFile1.xml" ;
//创建一个xml文档操作对象
XmlDocument doc = new XmlDocument ();
//创建一个xml文档头
XmlDeclaration declaration = doc.CreateXmlDeclaration( "1.0", "UTF-8" , null);
//将xml文档头添加到文档操作对象doc中
doc.AppendChild(declaration);
//doc.Save(filepath);
//创建子节点
//1.创建一个根节点
XmlElement root = doc.CreateElement("Scene" );
//2.将根节点添加到文档中
doc.AppendChild(root);
//在根节点下添加一个子节点
XmlElement child1 = doc.CreateElement("GameObject" );
//添加给root
root.AppendChild(child1);
//添加属性
XmlAttribute attr1 = doc.CreateAttribute("Name" );
attr1.Value = "Cube";
child1.SetAttributeNode(attr1);
child1.SetAttribute( "sex", "man" );
child1.SetAttribute( "Layer", "Water" );
child1.SetAttribute( "Tag", "宁" );
//为GameObject添加子节点
XmlElement child1_transform = doc.CreateElement("Transform" );
child1.AppendChild(child1_transform);
//位Transform添加三个子节点x，y，z
XmlElement child2_position = doc.CreateElement("Position" );
child1_transform.AppendChild(child2_position);
child2_position.SetAttribute( "x", "1" );
child2_position.SetAttribute( "y", "2" );
child2_position.SetAttribute( "z", "3" );
doc.Save(filepath);
}
生成的结果：
<?xml version="1.0" encoding =" UTF-8" ?>
<Scene>
<GameObject Name="Cube" sex =" man" Layer= "Water " Tag="宁" >
< Transform>
< Position x =" 1" y= "2 " z="3" />
</ Transform>
</GameObject>
</Scene>
2：xml的解析：
//解析xml文档（其实就是SelectSingleNode函数）
//public void readxml()
//{
// //实例化一个xml文档操作类
// XmlDocument doc = new XmlDocument();
// string xmlfilepath = Application.dataPath + "/Resources/XMLFile1.xml";
// //doc.Load(xmlfilepath);
// //获取元素的根节点
// XmlElement root = doc.DocumentElement;
// //Debug.Log(root.Name);
// //筛选节点
// XmlNode node1 = root.SelectSingleNode("GameObject");
// //sDebug.Log(node1.Name);
// XmlAttributeCollection attributes = node1.Attributes;
// foreach (var item in attributes)
// {
// XmlAttribute att = (XmlAttribute)item;
// Debug.Log(att.Name +":"+ att.Value);
// }
// XmlNode node1_transform = node1.SelectSingleNode("Transform");
// Debug.Log(node1_transform.Name);
// //解析剩下的节点
// XmlNode xnode = node1_transform.SelectSingleNode("x");
// XmlNode ynode = node1_transform.SelectSingleNode("y");
// //获取x节点下的文本内容
// Debug.Log(xnode.OuterXml);
// Debug.Log(ynode.InnerText);
//}
要想显示汉字必须把文件（例如text）格式改为UTF-8的形式；
Json数据生产：
using UnityEngine;
using System.Collections;
using System.Json;//引入命名空间
public class jeson : MonoBehaviour {
第一种：
public void CreatJsonstr()
{
//生成一个Json对象
JsonObject root = new JsonObject ();
root.Add( "HeroName", "诺克萨斯之手" );
root.Add( "HP", "58.6f" );
JsonObject skill1 = new JsonObject ();
skill1.Add( "skillname", "chuxue" );
skill1.Add( "skilltype", "Passive" );
skill1.Add( "xiaohao", "9/8/7/6" );
JsonObject skill2 = new JsonObject ();
skill2.Add( "adf", "afdf" );
skill2.Add( "sdafa", "iui" );
skill2.Add( "aufhuds", "asdfy" );
JsonArray cd = new JsonArray();
cd.Add(skill1);
cd.Add(skill2);
root.Add( "技能",cd);
string str = root.ToString();
Debug.Log(root);
}
第二种：（不理解）
JsonObject jo;
// Use this for initialization
void Start () {
//创建一个json对象
jo = new JsonObject();//相当于写好了一个大括号
//设置一个json值
JsonValue jv = "10";//int float string
//json对象添加键值对
jo.Add( "name", jv);
Debug.Log(jo.ToString());
//创建一个json数组
JsonValue[] sons = new JsonValue[] { "masterwang", "oldwang" };
//实例化一个json数组
JsonArray arr = new JsonArray(sons);
//json对象添加对象数组
jo.Add( "sons", arr);
//debug.log(jo.tostring());
HandOfLittleStudent();
}
void HandOfLittleStudent()
{
//创建技能q的Json对象
JsonObject skillq = new JsonObject ();
//添加一个技能名称
skillq.Add( "Q", "大厦四方" );
//创建一个数组对象
JsonArray cd = new JsonArray( new JsonValue[] { 9, 8, 7, 6, 5 });
skillq.Add( "冷却时间" ,cd);
skillq.Add( "消耗法力" , 30);
skillq.Add( "jo", jo);
Debug.Log(skillq);
}
}
=
Json数据解析：
using UnityEngine;
using System.Collections;
using LitJson;//引入解析明明空间
public class litjjjson : MonoBehaviour {
void Start ()
{
ParJson();
}
public void ParJson()
{
//解析第一个文本
TextAsset jsonfile1 = Resources .Load("transformtext" ) as TextAsset ;
string jsonstr1 = jsonfile1.text;
JsonData date1 = JsonMapper.ToObject(jsonstr1);
Debug.Log(date1[2][ "y"]);
//解析第二个文本；
//加载文件到text
TextAsset jsonfile = Resources.Load( "Json") as TextAsset ;
string jsonstr = jsonfile.text;
//将text转换成对象的格式
JsonData date = JsonMapper.ToObject(jsonstr);
//输出skills对象第2个的技能名字
Debug.Log(date[ "skills"][1]["skillName" ]);
}
}
//如何保存成为一个Json文件
粒子特效作者： 1056923207@qq.com |
1：粒子系统
2：拖尾渲染
3：线性渲染
4：贴图融合
1.粒子系统：粒子系统其实就是一个组件：Particle System。
Particle System组件面板如下：
using UnityEngine;
using System.Collections;
using UnityEngine.UI;
public class PlayerprefabsTest : MonoBehaviour {
/// <summary>
/// 本地数据的存储测试
/// </summary>
// Use this for initialization
public InputField Leval;
public InputField Score;
public InputField Name;
void Start ()
{
//Debug.Log(PlayerPrefs.GetInt("Leval"));
//Leval.text = PlayerPrefs.GetInt("Leval").ToString();
//Score.text = PlayerPrefs.GetFloat("Score").ToString();
//Name.text = PlayerPrefs.GetString("姓名");
}
// Update is called once per frame
void Update () {
}
public void savedate()
{
PlayerPrefs.SetInt("Leval" , 30);
PlayerPrefs.SetFloat("Score" , 153.6f);
PlayerPrefs.SetString("姓名" ,"张大鸡复活节第三zhang" );
}
public void ReadDate()
{
string rank = PlayerPrefs.GetInt("Leval" ).ToString();
float score = PlayerPrefs.GetFloat("Score" );
string name = PlayerPrefs.GetString("姓名" );
Leval.text = rank;
Score.text = score.ToString();
Name.text = name;
}
public void clearall()
{
PlayerPrefs.DeleteAll();
}
}
PlayerPrefaebs 小型游戏可以用：作者： 1056923207@qq.com |
PlayerPrefaebs 小型游戏可以用：
粒子特效作者： 1056923207@qq.com |
1：粒子系统
2：拖尾渲染：Trail Render
3：线性渲染：Line Render
4：贴图融合
1.粒子系统：粒子系统其实就是一个组件：Particle System。
Particle System组件面板如下：
线性渲染：
贴图融合：例如制作弹痕效果 ：
导航作者： 1056923207@qq.com |
步骤 ：
1：将想要烘焙的场景里的物体选中 然后Static里面选中NavigationStatic（导航静态）；
NavMeshAgent组件的属性，方法：
NavMeshAgent nav ;
float dis = nav.remainingDistance;
float sdis = nav.StoppingDistance;
nav.updatePosition=false;那么游戏对象的坐标固定不变;
nav.updateRotation=false;那么游戏对象的旋转固定不变：
nav.Stop()；//停止导航
首先在Windows窗口添加一个Navigation 在该面板设置相应的参数；
注意：上图左侧选中环境里需要烘焙的物体，右侧Object面板要选中Navigation Static（打上对勾）；
Bake界面：设置相应的参数；
游戏主角：添Nav Mesh Agent组件，这个组件是用来导航的 添加了这个组件才可以调用他的函数，比如setdestination等封装好的函数，如下图;
Area Mask组件：可以选择让组件挂在的游戏对象选择走那些路 不走哪些路；（分层）；
分离路面导航：
分离路面导航在组件：Off Mesh Link
组件的使用方法：在两个点上的一个挂上该组件就行，然后将两个物体拖进组件中；（该组件不是放在游戏主角上，而是放在环境物体身上）；
首先:
然后：
分层烘焙路面：
下图中Cost的值越小 优先级越高，相同条件下，主角会从该层行走。
在object面板设置层：如下图
主角设置为Walkbale 代表所有的层都可以走，
环境信息设置为另一个层 比如road1 （有一个Cost值 代表了该层的优先级）；
除了手动选择层外，还可以用代码实现：如下
动态障碍：
动态障碍功能实现的组件：Nav Mesh Obstcal,
面板如下层：
关于射线的笔记作者： 1056923207@qq.com |
RaycastHit rrr;
Ray hit = Camera.main.ScreenPointToRay( Input.mousePosition);
Physics.Raycast(hit, out rrr);
上述代码可以得到鼠标点击点的信息,rrr.point是一种position类型；
动画系统2作者： 1056923207@qq.com |
动画层：
Mask：遮罩 在JumpLayer加avator Mask （设置一下），权重weight 要设置为1；
IK Pass 勾上代表可以使用IK；
Avatar Mask组件；
IK动画的使用：
1：只有人型动画才能设置IK；
1：里面的权重（1f）表示任务抬手动作的大小，0代表不抬手，1代表完全指向目标：
2：将手指向，转向rightHandObj对象；（与lookat很相似）；
3：如果没有rightHandobj这个对象，则手不进行任何操作；
动画曲线：如果动画曲线叫Curve(如下图)，那么在parameter面板加一个同样名字的Float变量（这个变量的值随着图Curve的变化而变，大小一样），在脚本里利用GetFloat方法获取曲线的y值进行利用；
动画事件：Event；
下图是在Idle Walk 等动画里设置的 不是人物里面设置的；
注意：下图Object参数必须是一个预设体：
脚本必须放在人物身上，不是动画身上；
动画系统一作者： 1056923207@qq.com |
一：mecanim动画系统：]
1:任性动画设置和重用；
2：动画剪辑设置
3；可视化动画控制界面
4：动画播放的精准控制
动画类型：无任何动画 legacy 旧版动画 Generic 一般动画（非人性动画） Humanoid 人形动画
人性动画设置：
测试骨骼：肌肉测试
点击Done 回到正常界面
点击Import 如果现实下面的内容说明该模型没有动画；
模型没有动画的时候：Animations面板
模型有动画时的Animations面板：
把模型所包含的动画剪辑成的片段：点击+号可以添加剪辑片段-好可以删除选中的片段
动画剪辑面板：
动画编辑：
loop Time 让动画循环执行：
Loop Pose 让动画起始帧和末尾帧衔接更加自然，动画更加流畅；
Cycle Offset 设置动画开始执行的帧位置：
Loop Match 红色代表动画不能播放；黄色不能顺畅的播放；绿色可以；
Bake Into pose；烘焙进姿势：只有动作（例如动画有旋转的动作，但是坐标不改变，线面两个位移也是一样） 没有位移：
注意上面的Cycle Offset 和下面的Offset是不一样的 下面代表的是位置的便宜 上面代表的是动画整形循环的开始的帧位置：
mirror：当前动画是按照原动画执行动作，还是镜像里的动画执行动作：
Animator组件：
Controller：动画控制器
Avator：人物骨骼（阿凡达）；
Apply Root motion :只有勾选上,在动画设置里的改动才能应用，否则用的是原版动画，所有更改都没用啦;
Culling Mode :时间缩放；
Update：动画显示更新模式；
二State Machine状态机：
三：Blend Tree：融合树：
动画系统一作者： 1056923207@qq.com |
一：mecanim动画系统：]
1:任性动画设置和重用；
2：动画剪辑设置
3；可视化动画控制界面
4：动画播放的精准控制
动画类型：无任何动画 legacy 旧版动画 Generic 一般动画（非人性动画） Humanoid 人形动画
人性动画设置：
测试骨骼：肌肉测试
点击Done 回到正常界面
点击Import 如果现实下面的内容说明该模型没有动画；
模型没有动画的时候：Animations面板
模型有动画时的Animations面板：
把模型所包含的动画剪辑成的片段：点击+号可以添加剪辑片段-好可以删除选中的片段
动画剪辑面板：
动画编辑：
loop Time 让动画循环执行：
Loop Pose 让动画起始帧和末尾帧衔接更加自然，动画更加流畅；
Cycle Offset 设置动画开始执行的帧位置：
Loop Match 红色代表动画不能播放；黄色不能顺畅的播放；绿色可以；
Bake Into pose；烘焙进姿势：只有动作（例如动画有旋转的动作，但是坐标不改变，线面两个位移也是一样） 没有位移：
注意上面的Cycle Offset 和下面的Offset是不一样的 下面代表的是位置的便宜 上面代表的是动画整形循环的开始的帧位置：
mirror：当前动画是按照原动画执行动作，还是镜像里的动画执行动作：
Animator组件：
Controller：动画控制器
Avator：人物骨骼（阿凡达）；
Apply Root motion :只有勾选上,在动画设置里的改动才能应用，否则用的是原版动画，所有更改都没用啦；
二State Machine状态机：
三：Blend Tree：融合树：
动画的遮罩作者： 1056923207@qq.com |
状态机做两个层 在第二个层里加上AAnimatorMask 并且把他的Weight设置为1，两个层的页面如下：
基层：
另一层：正常状态不是Idle 而是New State（空状态）
单例类作者： 1056923207@qq.com |
单例的缺点：没有继承各种类和MoNo；unity的封装方法没办法用，部分可以使用（gameobject，tansform）如果用到了MONO的方法会异常处理（一些重要的代码用到，尤其是用户交互）；
单利类不放在任何组件对象身上，但是单利脚本（继承mono）必须放在对象身上；
单利类：
publicclassSImpple
{
private SImpple()
{
}
private static SImpple _instanse;
public static SImpple getinstanse()
{
if (_instanse == null)
{
_instanse = new SImpple();
}
return _instanse;
}
}
单例脚本
单利脚本的缺点，在切换场景的时候容易被销毁（解决办法：使用DontDestroyThis（）方法防止单例脚本被销毁）；
using UnityEngine;
using System.Collections;
public class SingleScript : MonoBehaviour
{
public static SingleScript _instance;
void Awake()
{
_instance = this;
}
}
单例类作者： 1056923207@qq.com |
单例的缺点：没有继承各种类和MoNo；unity的封装方法没办法用，部分可以使用（gameobject，tansform）如果用到了MONO的方法会异常处理（一些重要的代码用到，尤其是用户交互）；
单利类不放在任何组件对象身上，但是单利脚本（继承mono）必须放在对象身上；
单利类：
publicclassSImpple
{
private SImpple()
{
}
private static SImpple _instanse;
public static SImpple getinstanse()
{
if (_instanse == null)
{
_instanse = new SImpple();
}
return _instanse;
}
}
单例脚本
using UnityEngine;
using System.Collections;
public class SingleScript : MonoBehaviour
{
public static SingleScript _instance;
void Awake()
{
_instance = this;
}
}
EventSystem作者： 1056923207@qq.com |
一：添加 Event Trriger组件 不用写代码；
二：写代码如下:注意引入事件系统；实现接口继承
三：实现UI明明空间;(看start里面的方法，不能写在Update里面，只注册一次就行)，需要给脚本托一个脚本组件；
using UnityEngine;
using System.Collections;
using UnityEngine.EventSystems;
using System;
using UnityEngine.UI;
public class EventSystomText : MonoBehaviour,IPointerEnterHandler ,IPointerExitHandler ,IPointerDownHandler ,IPointerUpHandler ,IPointerClickHandler ,IBeginDragHandler ,IDragHandler ,IEndDragHandler ,
{
//第三种方法的代码
public Button btn;
public void OnBeginDrag( PointerEventData eventData)
{
Debug.Log( "开始拖拽" );
//throw new NotImplementedException();
}
public void OnDrag(PointerEventData eventData)
{
Debug.Log( "正在拖拽" );
//throw new NotImplementedException();
}
public void OnEndDrag( PointerEventData eventData)
{
Debug.Log( "结束拖拽" );
//throw new NotImplementedException();
}
public void OnPointerClick( PointerEventData eventData)
{
Debug.Log( "鼠标点击" );
// throw new NotImplementedException();
}
public void OnPointerDown( PointerEventData eventData)
{
Debug.Log( "鼠标按下" );
//throw new NotImplementedException();
}
public void OnPointerEnter( PointerEventData eventData)
{
Debug.Log( "shubiaojinre");
// throw new NotImplementedException();
}
public void OnPointerExit( PointerEventData eventData)
{
Debug.Log( "鼠标离开" );
//throw new NotImplementedException();
}
public void OnPointerUp( PointerEventData eventData)
{
Debug.Log( "鼠标抬起" );
// throw new NotImplementedException();
}
//第三种方法的代码
public void Res()
{
}
// Use this for initialization
void Start () {
//只执行一次就行
btn.onClick.AddListener(Res);
}
// Update is called once per frame
void Update () {
}
}
场景的加载作者： 1056923207@qq.com |
//1.读取新的关卡后立即切换，其参数为所读取的新关卡的名称或索引；
Application.LoadLevel("your scene" );
//2.加载一个新的场景，当前场景不会被销毁。
Application.LoadLevelAdditive("Your scene" );
//异步加载场景
//1.加载完进入新场景销毁之前场景
Application.LoadLevelAsync("Your Scene" );
//2.加载完毕进入新场景但是不销毁之前场景的游戏对象
Application.LoadLevelAdditiveAsync("Your Scene" );
Application(应用程序)作者： 1056923207@qq.com |
作用：1.加载游戏关卡场景
2.获取资源文件路径
3.退出当前游戏场景
4.获取当前游戏平台
5.获取数据文件夹路径
Application.Plateform 返回值为当前程序运行所在的平台；
Debug.Log(Application.runInBackground);可读可写，返回程序是否在后台运行的布尔值：
Application类的测试：
void Start()
{
//打印在哪个平台运行
Debug.Log( Application.platform);
//返回是否在后台运行（bool值）
Debug.Log( Application.runInBackground);
//当前工程的Assets文件夹位置（仅编辑器有）；
Debug.Log( Application.dataPath);
//持久路径
Debug.Log( Application.persistentDataPath);
//数据流路径
Debug.Log( Application.streamingAssetsPath);
//返回当前场景的索引号
Debug.Log( Application.loadedLevel);
}
输出结果：
坦克转向鼠标的位置作者： 1056923207@qq.com |
鼠标的位置转换成世界坐标： Vector3 WorldPoint =Camera.main.screenToWorldPoint(mousePoint)；
Vector3 direction =worldPoint -mGunTransform.position;
mGunTransform.rotation=Quternion.LookRotation(Vector3.forword,direction)
实现小地图的方法作者： 1056923207@qq.com |
在已经创建好的ui界面：首先议案家一个摄像机,然后将主摄像机的层级设置为1（大于新添加的摄像机），在创建一个Render Texture组件，创建一个RawImage组件，将该组件的北京图片换为刚才创建的Render Texture即可；
如果小地图里面物体的移动方向与主场景中的不一致，可以在sence里面调整新添加的相机的视角；
怎样实现小地图摄像机跟随某个物体移动：把小地图摄像机设置为想要跟随的目标的子物体就行：
实现小地图不显示实际的任务，只显示人物头像（类似lol小地图）：添加一个Canvas（Render Mode设置成世界模式（World Space），Event Camera设置成小地图的相机（渲染的时候将人物层剔除掉，主相机则是将人物头像（新建一个层，不能是原来的ui层）层剔除掉），将人物头像与任务xz坐标调成一致，）
添加遮罩作者： 1056923207@qq.com |
1.添加一个RawImage组件，背景图片选一张你想要显示的形状的无色的图片，在该组件上再添加一个Mask组件，将要显示的通篇放到该RawImage组件上；
血条，头像作者： 1056923207@qq.com |
遮罩：在父物体上添加Mask，在给其添加一个形状，在添加一个子物体图片，子物体的图片就会随着形状的改变而改变；
UGUI作者： 1056923207@qq.com |
Image组件：Image Type 可以做不同的功能；
Sprite作者： 1056923207@qq.com |
1，2D游戏相机设置为正交相机 size：5
2.资源切图
3.游戏背景设置成：在game视图中设置为Free Aspect;(自适应屏幕大小)
4.预制体的创建：炮口，炮弹，鱼；
2D动画的创建作者： 1056923207@qq.com |
选中切割好的图片，全部选中拖到Hierirychy面板中，给个动画名字，然后直接播放即可，也可以拖成预制体，
世界坐标与本地坐标的转换作者： 1056923207@qq.com |
将屏幕左边转换成世界坐标；transform.postion = Camera.main.ViewportToWorldpoint(Input.mouseposition);
transform.position = Camera.main.ViewportToWorldPoint( new Vector3(Input .mousePosition.x / Screen.width, Input.mousePosition.y / Screen.height, 4));
2D图片处理作者： 1056923207@qq.com |
如果不在工程设置里Edtor更改设置（DisAble，Enable forbuildings,Always Enable），那么系统会自动打包图片（即讲多张图片放到一张图片中）。
从一张打包好的图片里切割出小图片的好处：降低 CPU 的 DrawCall 切割出来的图片都算作一次Drawcall；
处理修改图片的组件：Sprite Renderer；
快速进入API：点击组件右侧的小问号。
触发器作者： 1056923207@qq.com |
碰撞器作者： 1056923207@qq.com |
1.碰撞器的大小可以人为地改变，来适应需求；
2.碰撞器的类型：胶囊体碰撞器，圆形碰撞器(2D)
3.OnCollisionEnter等回调方法需要有刚体；
4.GetComponent<MeshRenderer>().material.color=Color.red=new Color(255,0,0);两种方式是等价的； 可以改变物体的颜色；
对游戏对象的测速作者： 1056923207@qq.com |
1.两个触发器：一个触发器检测到车的触发器后继而拿到其刚体组件继而拿到其速度：
Transform类作者： 1056923207@qq.com |
静态类：Time.time 游戏从开始到现在运行的时间；
Vector3是一个结构体，常用属性：vector3.normalied：标准化向量 方向不变，长度为1；
vector3.magnitude 向量的长度（只读）；
vector3.sqrMagnitude：向量长度平方（只读）；
常用方法：vector3.Normalied（）：标准化向量，长度为1
static float Angle（Vector3 from，vector3 to）；两向量之间的角度
static float Distance（Vector a，Vector3 b）；两点之间的距离
transform.rotation = Quaternion.look(vector3.left,vector.up);
子弹飞行：子弹上的脚本Update里：
transform.Translate(Vector3.forward* Time.deltaTime*speed);
设置父对象：bullet.transform.parent=parent.transform;===bullet.transform.setparent(parent.transform);
通过设置Transform父子关系可以在敌人指定的部位产生爆炸流血特效；
float v =Input.Getaxis("Horizontal"); v是一个0到1之间的值
物体自转的公式;
transform.Rotate(transform.up * Time.deltaTime * Rspeed*hor);
7.13笔记 unity组件作者： 1056923207@qq.com |
一个游戏物体身上有很多的组件：
销毁游戏对象的两种方式：1,Destroy();继承MonoBehavior类
transform.Translate(vector3.up);改变的是本地坐标。
transform.position+=vector3.up;改变的是世界坐标。
transform.Rotate(vector3.up);
translate.RotateArround(new Vector3(0,0,0),Vector3.up,10(旋转角度，并不是速度。但是放到Update每秒执行多少次，其值的大小就可以代表速度啦))；
transform.LookAt(Target.Transform);让当前脚本挂载的物体朝向目标但是不移动；
Target.transform.localscale=new vector(2,2,2); 改变Target的缩放。
关于射线的知识点作者： 1056923207@qq.com |
Debug.Draw()方法是持续执行的必须放在update()里面才能看到划线，而且只能在Scene里面才能看到在Game视图看不到；
代码如下：
public class CameraRay : MonoBehaviour
{
RaycastHit Hit;
void Start()
{
bool isRaycast = Physics.Raycast( new Vector3(0, 1, 0), Vector3.down, out Hit);
if (isRaycast)
{
Debug.Log(Hit.point);
}
}
void Update()
{
Debug.DrawLine( new Vector3(0, 10, 0), Hit.point, Color.red);
}
}
关于物体的移动作者： 1056923207@qq.com |
如果想让物体的速度由快到慢：就用lerp函数：transform.position=vector3.Lerp(transform.position,Target,Time.delTime);
第二种移动方法： float hor= Input.GetAxis("Horizontal");
float ver = Input.GetAxis("Vertical");
transform.position +=new Vector3(hor,ver,0)*Time.delTime;
第二种方法的第二种写法： float hor = Input .GetAxis("Horizontal" );
transform.position += transform.right * hor * Time.deltaTime * speed;
寻找当前脚本挂在物体的子物体作者： 1056923207@qq.com |
point= transform.Find("Gun/Point");
纹理和材质球一般是配合使用的；想要变得更逼真，就把贴图变成map的作者： 1056923207@qq.com |
纹理和材质球一般是配合使用的；想要变得更逼真，就把贴图变成map的
射线的创建作者： 1056923207@qq.com |
鼠标拖拽物体作者： 1056923207@qq.com |
using UnityEngine;
using System.Collections;
public class Script1 : MonoBehaviour
{
public float movespeed;
private Vector3 PresentPosition;
private Vector3 CurrentPosition;
void OnMouseDown()
{
PresentPosition= Input.mousePosition;
}
void OnMouseDrag()
{
CurrentPosition = Input.mousePosition;
Vector3 dir = CurrentPosition - PresentPosition;
transform.position += dir*movespeed;
PresentPosition = CurrentPosition;
}
void Update()
{
OnMouseDown();
OnMouseDrag();
}
}
10抽象类，静态类作者： 574096324@qq.com |
//如果一个方法前面用abstruct来修饰，改方法为抽象方法，同时需要把该抽象方法所在的类改为抽象类
//所有的子类都要把父类的抽象方法重写,如果父类里面有多个抽象方法，则必须实现
//抽象类不能实例化，他可以用普通的子类进行实例化
//抽象类里面可以不包含抽象方法，此时除了不能实例化以外，和普通的类没有任何区别
//如果子类仪式抽象类，可以不用实现父类里面的抽象方法
public abstract void Train();
public string Name { get; set; }
public void Run()
{
}
}
abstract class Person
{
public string Name { get; set; }
public void Talk()
{
}
}
class FootballPlayer : Athlete
{
public override void Train()
{
Console.WriteLine("足球运动员训练" );
}
}
abstract class ManFootball :FootballPlayer
{
public override void Train()
{
}
}
class Swimmer: Athlete
{
public override void Train()
{
Console.WriteLine("游泳运动员训练" );
}
}
class Runner: Athlete
{
public override void Train()
{
Console.WriteLine("短跑运动员训练" );
}
}
abstract class Ball
{
public abstract void Play();
}
class Basketball : Ball
{
public override void Play()
{
Console.WriteLine("打篮球" );
}
}
class Football : Ball
{
public override void Play()
{
Console.WriteLine("踢足球" );
}
}
class Volleyball : Ball
{
public override void Play()
{
Console.WriteLine("打排球" );
}
}
单例
class Hero
{
//1.要保证该类只能创建出一个对象，则构造方法就不能为公有的，这样就可以在类的内部创建出一个对象
//然后通过属性在类的外部得到该对象
private Hero()
{
}
//2.在类的内部声明一个Hero的对象，但不赋值，即没有new运算符在内存中开辟空间，此时其值为空
private static Hero instance;
//3.由于构造方法为私有的，类的外部不能创建对象来调用普通的属性，故把属性写成静态的，通过类名来调用该属性
//而静态属性只能调用静态成员，故要把instance写成静态的
public static Hero Instance
{
get
{
//判断instance是否为空，当第一次调用时其值为空，则执行if语句，就会创建一个对象出来，当第二次调用时，
//instance已经不为空，if语句就不会执行了，会把第一个创建的对象返回出去，这样就保证了该类的对象时唯一的一个
if (instance==null )
{
instance = new Hero ();
}
return instance;
}
}
}
枚举，结构体作者： 574096324@qq.com |
结构体数组结合
找最大最小值，先定义一个max，与max比较，一次循环
排序，冒泡，两次循环，i<length-1,j<length-1-i,
按年龄排序，要交换整个Student 类型的temp;
int c = char.Parse(Console.ReadLine());
PlayerStatus player = (PlayerStatus)c;
PlayerStatus player = (PlayerStatus )char.Parse( Console .ReadLine());
Console .WriteLine(player);
//StuInfos[] stu = new StuInfos[5];
//double maxScore = stu[0].score;
//int maxIndex = 0;
//for (int i = 0; i < stu.Length; i++)
//{
// StuInfos s;
// Console.WriteLine("请输入第{0}个学生的姓名:", i + 1);
// string inputName = Console.ReadLine();
// s.name = inputName;
// Console.WriteLine("请输入第{0}个学生的年龄:", i + 1);
// int inputAge = int.Parse(Console.ReadLine());
// s.age = inputAge;
// Console.WriteLine("请输入第{0}个学生的学号:", i + 1);
// int inputNumber = int.Parse(Console.ReadLine());
// s.number = inputNumber;
// Console.WriteLine("请输入第{0}个学生的分数:", i + 1);
// double inputScore = double.Parse(Console.ReadLine());
// s.score = inputScore;
// //把变量s存到stu的数组里面
// stu[i] = s;
//}
////把数组打印出来
//for (int i = 0; i < stu.Length; i++)
//{
// Console.WriteLine("{0},{1},{2},{3}", stu[i].name,
// stu[i].age, stu[i].number, stu[i].score);
//}
////找数组里面的最大分数值
//for (int i = 0; i < stu.Length; i++)
//{
// if (maxScore < stu[i].score)
// {
// maxScore = stu[i].score;
// maxIndex = i;
// }
//}
//Console.WriteLine("最高分数是{0}", maxScore);
//Console.WriteLine("该分数对应的学生信息是:");
//Console.WriteLine("{0},{1},{2},{3}", stu[maxIndex].name,
// stu[maxIndex].age, stu[maxIndex].number, stu[maxIndex].score);
//for (int i = 0; i < stu.Length - 1; i++)
//{
// for (int j = 0; j < stu.Length - 1 - i; j++)
// {
// //比较数组元素的年龄的大小
// if (stu[j].age < stu[j + 1].age)
// {
// //交换的时候,是要把整个元素进行交换
// //不能只交换数组元素的某一个值,而数组
// //里面的元素类型是StuInfos类型
// //故要定义一个该类型的中间变量来
// //进行交换
// StuInfos temp = stu[j];
// stu[j] = stu[j + 1];
// stu[j + 1] = temp;
// }
// }
//}
////把数组打印出来
//for (int i = 0; i < stu.Length; i++)
//{
// Console.WriteLine("{0},{1},{2},{3}", stu[i].name,
// stu[i].age, stu[i].number, stu[i].score);
//}
////找数组里面的最大值
//double maxScore = stu[0].score;
//for (int i = 0; i < stu.Length; i++)
//{
// Console.WriteLine("{0},{1},{2},{3}", stu[i].name,
// stu[i].age, stu[i].number, stu[i].score);
//}
////找数组里面的最大分数值
//int maxIndex = 0;
//for (int i = 0; i < stu.Length; i++)
//{
// if (maxScore < stu[i].score)
// {
// maxScore = stu[i].score;
// maxIndex = i;
// }
//}
//Console.WriteLine("最高分数是{0}", maxScore);
//Console.WriteLine("该分数对应的学生信息是:");
//Console.WriteLine("{0},{1},{2},{3}", stu[maxIndex].name,
// stu[maxIndex].age, stu[maxIndex].number, stu[maxIndex].score);
//for (int i = 0; i < stu.Length-1; i++)
//{
// for (int j = 0; j < stu.Length-1-i; j++)
// {
// if (stu[j].age < stu[j + 1].age)
// Student temp = stu[j];
// stu[j] = stu[j + 1]; // {
// stu[j + 1] = temp;
// }
// }
//}
字符串，重载，递归作者： 574096324@qq.com |
字符串
//string str = "lanou,keji,hello/world$bie";
//string str1 = str;
//str1 = "keji";
//Console.WriteLine(str+str1);
检测字符串中是否包含指定的字符串
//bool b = str.Contains('a');
//Console.WriteLine(b);
返回字符串中首次出现指定字符的下标位置
//int i = str.IndexOf('l');
//Console.WriteLine(i);
返回字符串中最后次出现指定字符的下标位置
//int j = str.LastIndexOf('l');
//Console.WriteLine(j);
左对齐
//string str1 = str.PadLeft(30);
//Console.WriteLine(str1);
右对齐
//string str2 = str.PadRight(30);
//Console.WriteLine(str2);
从指定下标位置删除后面的字符串
//string str3 = str.Remove(10, 5);
//Console.WriteLine(str3);
替换指定子字符或字符串
//string str4 = str.Replace("bei", "beijing");
//Console.WriteLine(str4);
使用指定的字符标志来分割字符串，获得子字符串
//char[] c = new char[] { ',' };
//string[] str5 = str.Split(c);
//Console.WriteLine(str5.Length);
//foreach (string item in str5)
//{
// Console.WriteLine(item);
//}
转成大写
//Console.WriteLine(str.ToUpper());
//string str7 = str.Trim(' ');
//Console.WriteLine(str7);
从给定下标位置输出后面的字符串
//string str8 = str.Substring(3, 5);
//Console.WriteLine(str8);
方法的重载
1.方法名相同
2.参数不同 ( 1）参数类型不同 (2）参数个数不同
递归
public double Sum(int n)
{
if (n==1)
{
return 1;
}
return Sum(n - 1)+n;
}
异常捕捉作者： 1056923207@qq.com |
如果try里面有错误就执行catch里面的代码，否则不执行catch；但是不管try里面有没有错误都会执行finally里面的内容；
try{
int a = int.Parse(Console.ReadLine());
}
catch{
Console.Write("成功的捕捉到了异常");
}finally{
a=1；
}
13委托 事件作者： 574096324@qq.com |
课堂练习
using System;
using System.Collections.Generic;
namespace Lesson13_3
{
//张三:初版按钮的实现
/*class Button
{
public string BtnName { get; set;}
public Button(string btnName){
BtnName = btnName;
}
public void Onclick(){
Console.WriteLine (BtnName+ "：被点击了");
if (BtnName == "登录") {
LoginPageLogic logic = new LoginPageLogic ();
logic.Login ();
} else if (BtnName == "取消") {
LoginPageLogic logic = new LoginPageLogic ();
logic.CancelLogin ();
}
}
public void Onclick(Hero h){
if (BtnName == "a1") {
h.LeftAction ();
}
}
}*/
//张三:委托版按钮的实现
class Button
{
//定义一个按钮委托
public delegate void OnclickHandler ();
//定义一个委托变量，用来存放点击操作的具体方法
public OnclickHandler oncliAction;
public void AddOnclickAction(OnclickHandler param){
oncliAction = param;
}
public string BtnName { get; set;}
public Button(string btnName){
BtnName = btnName;
}
//按钮点击的时候调用的方法
public void Onclick(Action< string> callBack){
Console.WriteLine (BtnName+ "：被点击了" );
if (oncliAction != null ) {
//执行委托
oncliAction ();
}
if (callBack != null ) {
callBack (BtnName);
}
}
}
//李四：登录页面逻辑
class LoginPageLogic {
public void Login(){
Console.WriteLine ("登录成功" );
}
public void CancelLogin(){
Console.WriteLine ("取消登录" );
}
}
//王二： 英雄类
class Hero
{
public string HeroName{ get; set;}
public void LeftAction(){
Console.WriteLine (HeroName+" 正在犀利的向左走位" );
}
public void RightAction(){
Console.WriteLine (HeroName+" 正在犀利的向右走位" );
}
}
class PrintTool {
//定义一个判断字符串是否相等的方法委托
public delegate bool StringIsEquals( string str1,string str2);
public static void PrintIntArr( int[] arr){
foreach (int item in arr) {
Console.WriteLine (item);
}
}
//判断两个字符串是否相等的方法
public bool ArrayisEquals(string str1, string str2){
/*if (str1 == str2) {
return true;
} else
return false;*/
return str1 == str2;
}
}
class MainClass
{
public static void Main ( string[] args)
{
//委托的定义格式：
//访问修饰符 delegate 返回值类型 委托名称 (参数列表)
//访问修饰符 返回值类型 方法名称 (参数列表)
//委托的用法：
//1、声明委托
VoidFunction action;
//2、绑定委托
// 1.直接赋值
//action = EngGreeting;
// 2.通过new关键字来初始化绑定
action = new VoidFunction (EngGreeting);
//3、调用（和方法的调用类似）
//action ("张三");
//4、多播委托，可以将多个方法通过+=运算符绑定到一个委托上
// 调用委托的时候，会将委托上绑定的方法分别执行
action += ChineseGreeting;
action ("李四" );
//1、绑定实例对象的方法
/*PrintTool print = new PrintTool ();
//声明委托
Print printArr = new Print (print.PrintIntArr);
int[] result = new int[6]{ 1,2,3,4,5,6};
printArr (result);*/
//2、
int[] arr = new int[5]{ 1,2,3,4,5};
Print printArr = new Print ( PrintTool.PrintIntArr);
printArr (arr);
PrintTool tool = new PrintTool ();
PrintTool.StringIsEquals isEquals = new PrintTool. StringIsEquals (tool.ArrayisEquals);
bool result = isEquals ("a" ,"a");
Console.WriteLine (result);
List<int > arrlist = new List< int> ();
arrlist.Add (2);
arrlist.Add (1);
arrlist.Add (5);
arrlist.Add (3);
arrlist.Sort ();
foreach (var item in arrlist) {
Console.WriteLine (item);
}
Console.Clear ();
//合并委托： 如果委托有返回值，那么返回值就是最后绑定的方法的返回值
Addelegate del = Add;
del += Mul;
int result1 = del (2,3);
Console.WriteLine (result1);
//解除绑定：注意委托不能为null
del -= Mul;
del -= Mul;
//del -= Add;
Console.WriteLine (del(2,3));
//登录，取消页面逻辑
LoginPageLogic page = new LoginPageLogic ();
//登录按钮
Button loginBtn = new Button ( "登录");
//为登录按钮绑定登录逻辑
loginBtn.AddOnclickAction (page.Login);
loginBtn.Onclick (delegate(string message){
Console.WriteLine (message);
});
//为取消按钮绑定取消登录的逻辑
Button cancelBtn = new Button ( "取消");
cancelBtn.oncliAction = page.CancelLogin;
cancelBtn.Onclick (null);
Hero dema = new Hero ();
dema.HeroName = "德玛西亚" ;
//向左操作按钮
Button leftBtn = new Button ( "a1");
leftBtn.oncliAction = dema.LeftAction;
leftBtn.Onclick (null);
//s向左操作按钮
Button rightBtn = new Button ( "d1");
rightBtn.oncliAction = dema.RightAction;
//匿名方法1、无返回值的匿名方法：delegate(参数列表){ 方法体 }2、有返回值的匿名方法：delegate(int x,int y){return x+y}3、在将匿名方法赋值给委托的时候，末尾的 ; 不能忘
Addelegate delAdd = delegate (int x, int y) {
return x + y;
};
//2、lambda表达式：
delAdd = (int x,int y) => {
return x*y;
};
Console.WriteLine (delAdd (4,5));
//Func:范型委托
Func<int ,int ,string, float> chu = (int x,int y,string name) => {
Console.WriteLine (name);
return x+y;
};
Console.WriteLine (chu(3,5,"张三" ));
}
//定义打印数组的委托
public delegate int Addelegate( int x,int y);
public delegate void Print(int[] arr);
public delegate void VoidFunction( string _n);
public static void ChineseGreeting( string name){
Console.WriteLine ("早上好：" +name);
}
public static void EngGreeting( string name){
Console.WriteLine ("good morning:" +name);
}
public static int Add( int x,int y){
return x + y;
}
public static int Mul( int x,int y){
return x * y;
}
}
}
//================================================================
using System;
namespace Lesson13_2
{
public class Person{
public string name;
public void Congratulate(){
Console.WriteLine (this .name+" 祝贺新郎新娘百年好合～！" );
}
}
public class Button{
public string btnName;
//事件的
public delegate void OnclickHandler();
public event OnclickHandler ClickEvent;
public void AddClickListener(OnclickHandler clickCall){
ClickEvent += new OnclickHandler (clickCall);
}
public void Onclick(){
if (ClickEvent != null ) {
ClickEvent ();
}
}
}
public class CJBoy{
public delegate void MarryHandle();
//事件的发起者
public event MarryHandle marryEvent;
public void SayLove(string qs){
Console.WriteLine ("黑负泪" );
}
public void XYQ(){
Console.WriteLine ("送玫瑰" );
}
public void Song(){
Console.WriteLine ("你笑的多甜蜜蜜蜜" );
}
public bool Ask(string name){
Console.WriteLine ("你到底接不接受" );
return true ;
}
public long PhoneNum(){
return 133010556;
}
public void SendMessage(Action callback){
if (callback != null ) {
callback ();
}
}
//给事件添加一个监听
public void AddMarryListener(MarryHandle listener){
marryEvent += new MarryHandle (listener);
}
public void Marry(){
Console.WriteLine ("要结婚了" );
//事件触发
if (marryEvent != null ) {
marryEvent ();
}
}
}
//delegate bool AskHandle();
//delegate bool AskHandle(string name);
class MainClass
{
public static void Main ( string[] args)
{
CJBoy boy = new CJBoy ();
//Func：用于创建有返回值类型的委托，
//注意，返回值一定义是最后那个参数
Func<string ,bool> laowang
= new Func <string, bool> (boy.Ask);
bool result = laowang ("超级男孩" );
Console.WriteLine (result);
Func<long > laowang2 = new Func< long> (boy.PhoneNum);
Console.WriteLine (laowang2 ());
//Action: 用于创建没有返回值类型的委托
Action<string > laowang3
= new Action <string> (boy.SayLove);
laowang3 ("流浪" );
Action laowang4 = new Action (boy.Song);
laowang4 ();
boy.SendMessage (delegate(){
Console.WriteLine ("吃饭了吗～！" );
});
Person plaowang = new Person();
plaowang.name = "老王" ;
Person p2 = new Person();
p2.name = "老张" ;
Person p3 = new Person();
p3.name = "老李" ;
boy.AddMarryListener (plaowang.Congratulate);
boy.AddMarryListener (p2.Congratulate);
boy.AddMarryListener (p3.Congratulate);
//结婚当天
boy.Marry ();
//
Button loginBtn = new Button ();
loginBtn.AddClickListener (delegate(){
Console.WriteLine ("登陆" );
});
Button cancelBtn = new Button ();
cancelBtn.AddClickListener (delegate(){
Console.WriteLine ("取消登陆" );
});
Button skill1Btn = new Button ();
skill1Btn.AddClickListener (delegate(){
Console.WriteLine ("大招" );
});
loginBtn.Onclick ();
cancelBtn.Onclick ();
skill1Btn.Onclick ();
}
}
}
委托作者： 1056923207@qq.com |
委托的定义位置，可以放到类和方法同级，
也可以放到命名空间下和类同级。
委托的返回值：多播委托的返回值是最后一个方法的返回值；
匿名委托格式： Pao p = delegate(){return 0 ;};
有参数有返回值的匿名委托：
一，用于创建有返回值类型的委托就用泛型委托；注意：返回值一定是尖括号最后的那个参数；
泛型委托：1. Func<bool> laowang =new Func<bool>(bool.Ask);
bool result = laowang();
2. Func<string ,bool> laowang =new Func<string,bool>(bool.Ask);
二， Actiong：用于创建没有返回值类型的委托:
Action<string> laowang3 = new Action<string>(boy.SayLove);
12作业作者： 574096324@qq.com |
《第十二讲：C#语言编程》集合
课后题：
1. （*）用集合保存4个人的随机投票，列出最终票数及各自的名字
2. （* *）在一个有限平面区域上（1000 ＊ 1000）随机生成有序的n个点（用结构体表示点），将其保存在集合中
（1）输出所有点的坐标信息
（2）计算有序相邻两点距离之和（先排序，再求距离）
3. （* * *）队列：仿照模拟经营类游戏中的情形，自定义一个窗口类，实例化一个窗口，一共有10位顾客，每位顾客接受服务的时间为2～3分钟，求15分钟后仍为接受服务的顾客名单。
using System;
//非范型集合所在的命名空间
using System.Collections;
//范型集合命名空间
using System.Collections.Generic;
namespace Lesson12
{
public class PrintTool{
//专门输出队列的元素
public void PrintStack(Stack a){
foreach (var item in a) {
Console.Write (item+" " );
}
}
public void PrintQueue(Queue< string> q){
foreach (var item in q) {
Console.Write (item+" " );
}
Console.WriteLine ();
}
}
class MainClass
{
public static void Main ( string[] args)
{
//集合：把一些能够确定的不同的对象看成一个整体，
// 就说这个整体是由这些对象的全体构成的集合.
//元素：集合中每个对象叫做这个集合的元素.
PrintTool zhangsan = new PrintTool ();
Stack stack = new Stack ();
//Push:往集合里放一个东西
stack.Push (1);
stack.Push (5.4f);
stack.Push ("你好～！" );
//可以用foreach访问Stack集合里的元素
zhangsan.PrintStack (stack);
//Pop：返回并移除集合顶部的对象
object propItem = stack.Pop ();
Console.WriteLine (propItem);
//可以用foreach访问Stack集合里的元素
zhangsan.PrintStack (stack);
object peekItem = stack.Peek ();
//赋值语句，条件语句
//stack.Clear ();
Queue<string > queue = new Queue< string> ();
queue.Enqueue ("张三" );
queue.Enqueue ("李四" );
queue.Enqueue ("王二" );
queue.Enqueue ("麻子" );
queue.Enqueue ("老王" );
zhangsan.PrintQueue (queue);
//返回队列的第一个元素，并将这个元素从集合中删除
string dequeueItem = queue.Dequeue ();
Console.WriteLine (dequeueItem);
zhangsan.PrintQueue (queue);
//
//Dictionary：字典集合
Dictionary<int ,string> students =
new Dictionary <int, string> ();
//往字典里存放值，key是唯一的，不能重复添加key
students.Add (1, "李逵" );
students.Add (2, "张飞" );
students.Add (3, "宋江" );
students.Add (4, "关羽" );
//用foreach迭代集合中的元素
foreach (var item in students) {
Console.WriteLine (item.Value);
}
//元素的访问：变量名称[key（键）]形式来访问单个value元素
Console.WriteLine (students [1]);
//在直接通过索引方式去值的时候，
//要注意key在存在情况下才能去成功否则或报错
if (students.ContainsKey (5)) {
Console.WriteLine (students [5]);
} else {
Console.WriteLine ("key不存在" );
}
string value;
bool isGet = students.TryGetValue (5, out value);
Console.WriteLine (isGet + " " + value);
//移除键以及键所对应的元素
students.Remove (1);
//用foreach迭代集合中的元素
foreach (var item in students) {
Console.WriteLine (item);
}
//判断是否存在指定的值
Console.WriteLine (students.ContainsValue ("张飞"));
//取得集合中的所有键
Dictionary<int ,string>. KeyCollection keys = students.Keys;
foreach (var item in keys) {
Console.WriteLine (item);
}
// “张三 ，2”
// "李四 ，5"
// “wanger , 3”
// Dictionary<string,int> voite = new Dictionary<string, int> ();
// for (int i = 0; i < 10; i++) {
// string name = Console.ReadLine ();
// if (!voite.ContainsKey (name)) {
// voite.Add (name, 1);
// } else {
// voite [name] += 1;
// }
// }
//
// foreach (var item in voite) {
// Console.WriteLine (item);
// }
//List<T> 动态数组
List<int > scores = new List< int> ();
scores.Add (1);
scores.Add (2);
scores.Add (3);
scores.Add (4);
scores.Add (5);
//Insert，从指定的索引位置插入元素
scores.Insert (3, 6);
//Remove:删除指定元素
scores.Remove (6);
//RemoveAt:删除指定索引位置的元素
//Reverse：
scores.Reverse ();
//
scores.Sort ();
foreach (var item in scores) {
Console.WriteLine (item);
}
}
}
}
ArryList和List<T>作者： 1056923207@qq.com |
《第十二讲：C#语言编程》集合
课后题：
1. （*）用集合保存4个人的随机投票，列出最终票数及各自的名字
2. （* *）在一个有限平面区域上（1000 ＊ 1000）随机生成有序的n个点（用结构体表示点），将其保存在集合中
（1）输出所有点的坐标信息
（2）计算有序相邻两点距离之和（先排序，再求距离）
课后题：
1. （*）用集合保存4个人的随机投票，列出最终票数及各自的名字
2. （* *）在一个有限平面区域上（1000 ＊ 1000）随机生成有序的n个点（用结构体表示点），将其保存在集合中
（1）输出所有点的坐标信息
（2）计算有序相邻两点距离之和（先排序，再求距离）
3. （* * *）队列：仿照模拟经营类游戏中的情形，自定义一个窗口类，实例化一个窗口，一共有10位顾客，每位顾客接受服务的时间为2～3分钟，求15分钟后仍未接受服务的顾客名单。
第一题：
//实例化一个字典对象（代码放在主函数里面）
Dictionary<string , int > dic = new Dictionary< string, int>();
for ( int i = 0; i < 4; i++)
{
string name = Console.ReadLine();
if (dic.ContainsKey(name))
{
dic[name] += 1;
}
else
{
dic.Add(name, 1);
}
}
foreach ( var item in dic)
{
Console.WriteLine(item);
}
第二题：
（1）
namespace 集合
{
struct Point
{
public float x;
public float y;
}
class Program
{
static void Main( string[] args)
{
List< Point> li = new List< Point>();
Random ran = new Random();
Point p = new Point();
for ( int i = 0; i < 5; i++)
{
p.x = ran.Next(0, 1000);
p.y = ran.Next(0, 1000);
li.Add(p);
}
foreach ( var item in li)
{
Console.WriteLine( "x坐标为{0}，y坐标为{1}" ,item.x,item.y);
}
}
}
}
第二题
namespace 集合
{
public struct Point
{
public float x;
public float y;
}
public static class Tool
{
public static double Dis( Point p1, Point p2)
{
double m = (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y);
double z = Math.Sqrt(m);
return z;
}
}
class Program
{
static void Main( string[] args)
{
List< Point> li = new List< Point>();
Random ran = new Random();
Point p = new Point();
for ( int i = 0; i < 5; i++)
{
p.x = ran.Next(0, 1000);
p.y = ran.Next(0, 1000);
li.Add(p);
}
for ( int i = 0; i < 4; i++)
{
for ( int j = 0; j < 4-i; j++)
{
if (li[j].x>li[j+1].x)
{
Point item = li[j];
li[j] = li[j + 1];
li[j + 1] = item;
}
}
}
double totaldistance = 0;
for ( int i = 4; i > 0; i--)
{
totaldistance += Tool.Dis(li[i], li[i -1]);
}
Console.WriteLine(totaldistance);
foreach ( var item in li)
{
Console.WriteLine( "x坐标为{0}，y坐标为{1}" ,item.x,item.y);
}
}
}
}
第三题：
class Program
{
static void Main( string[] args)
{
Random ran = new Random();
Queue< int> t = new Queue< int>();
int sum = 0;
int z;
for ( int i = 0; i < 9; i++)
{
int n = ran.Next(2, 4);
sum += n;
if (sum <= 15)
{
t.Enqueue(n);
}
else
{
z = 9 - i;
Console.WriteLine( "还有{0}位客人没有接受服务" , z);
break;
}
}
}
}
冒泡排序，选择排序作者： 574096324@qq.com |
冒泡排序
int[] a = { 48, 39, 65, 97, 76, 13 };
for (int i = 0; i < a.Length-1; i++)
{
for (int j = 0; j < a.Length-1-i; j++)
{
if(a[j]>a[j+1])
{
int temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
for (int i = 0; i < a.Length; i++)
{
Console.WriteLine(a[i]);
}
////选择排序
//int[] a = { 48, 39, 65, 97, 76, 13 };
////每一趟都会找出一个最小值，第一堂吧最小值与第一个元素交换，第二趟找出除第一个元素之外的元素里面的最小值
////并与第二个元素进行交换，以此类推
////声明两个变量一个存放最小值，一个存放最小值对应的下标
//int min, minIndex;
////外层循环控制趟数
//for (int i = 0; i < a.Length-1; i++)
//{
// //当i等于0，把a[0]当成最小值，如果i=1,则把a[1]当成最小值
// min = a[i];
// minIndex = i;
// for (int j =i+1 ; j <a.Length ; j++)
// {
// if (min>a[j])
// {
// min = a[j];
// minIndex = j;
// }
// }
// //把a[i]的值与最小值所在下标的元素进行交换
// a[minIndex] = a[i];
// //把最小值min赋值给a[i],完成两个元素值得交换
// a[i] = min;
//}
//for (int i = 0; i < a.Length; i++)
//{
// Console.WriteLine(a[i]);
//}
int[,] a = new int[4, 3];
for (int i = 0; i < a.GetLength(0); i++)
{
for (int j = 0; j < a.GetLength(1); j++)
{
a[i, j] = int.Parse(Console.ReadLine());
}
}
//打印数组
for (int i = 0; i < a.GetLength(0); i++)
{
for (int j = 0; j < a.GetLength(1); j++)
{
Console.Write(a[i, j] + " ");
}
Console.WriteLine();
}
for (int i = 0; i < a.GetLength(1); i++)
{
Console.Write(a[0, i] + " ");
}
int sum = 0;
for (int i = 0; i < a.GetLength(1); i++)
{
sum += a[1, i];
}
{
for (int j = 0; j < a.GetLength(1); j++)
{
a[i, j] = int.Parse(Console.ReadLine());
}
}
//打印数组
for (int i = 0; i < a.GetLength(0); i++)
{
for (int j = 0; j < a.GetLength(1); j++)
{
Console.Write(a[i, j] + " ");
}
Console.WriteLine();
}
for (int i = 0; i < a.GetLength(1); i++)
{
Console.Write(a[0, i] + " ");
}
int sum = 0;
for (int i = 0; i < a.GetLength(1); i++)
{
sum += a[1, i];
}
Console.WriteLine("sum=" + sum);
类名方法名大写
unity引擎组件作者： 1056923207@qq.com |
两种打印的方式：1.print,继承于MonoBehaviour类；只有在继承MoNoBehaviour类的时候才能用
2. debug.log； debug类中还有两个只能在Sence模块看到的测试划线1.Drawline（Vector3 start，Vector3 end）;
2.DrawRay(Vector3 start,Vector3 dir);
GameObect类的属性：tag，name FindGameObjectsWithTag(string tag) T GetComponent<T>() SetActive(bool value) FindWithTag(string tag)
集合作者： 1056923207@qq.com |
字典元素的访问：可以用foreach将字典键值对的完整信息打印出来，也可以通过索引仅仅输出键的值、
在直接通过索引取值的时候要注意：key值要在存在的情况下才能取成功;
抽象方法作者： 1056923207@qq.com |
抽象方法：在父类中定义不能实现
;只能出现在抽象类中
：方法返回值前面要加abstract
;子类实现抽象方法的时候需要加abstract；
基本数据类型作者： 574096324@qq.com |
1.int类型 4字节 32位整型 uint 无符号整型 unsigned
2. 单精度浮点数（float）4字节 后面加f，例如：23.5f，23f
3.双精度浮点数（double）8字节 后面加d 也可不加，例如：23.5，14.7d
4.128位高精度浮点数（decima） 16字节 后缀m ，例如：15.67m，它的取值范围上面两种浮点类型小，但精确度最高。
5.字符类型（char）2字节，用单引号引起来，例如‘0’
6.字符串（string）由0个，1个或者2个以上的字符组成并用双引号引起来，“0”，“1”，“lisi”
7.布尔类型（bool），取值只能为true或false
数组，枚举，结构体
枚举，结构体作者： 1056923207@qq.com |
枚举类型的变量只有赋值之后才能使用，并且所赋的值必须是有效的：不同的枚举可以有相同的值，不会冲突，比如week.day和month.day;
结构体：使用结构体的成员时的格式：结构体类型变量.成员名 Person p ; p.name=nignyognbin;
:结构体的成员都不允许直接初始化（不能直接赋值）：
泛型作者： 1056923207@qq.com |
泛型方法：public void 方法名字 <类型>（）{}
泛型类：Test<int> a = new Test<int> ();
泛型参数的约束：public class Test<T>Where T:Struct {} 只能是值类型的
：public class Test<T>Where T:Class {} 只能是引用类型的
接口与泛型作者： 574096324@qq.com |
接口与泛型
1.接口的定义：访问修饰符interface接口名{成员}
2.接口是一个抽象的该年，目的在于子类实现它
3.接口通常用来定义不同类之间的统一的标准
4.接口的成员：包括方法、属性、事件、索引、不能有字段
5.接口成员不能加修饰符，默认为public并且要求实现类（子类）去实现接口里的所有接口成员
6.接口和抽象类一样，是抽象的概念，所以不能创建对象（不能new）
7.如果一个类实现多个接口，接口之间用逗号","
8如果一个类同时继承一个父类，又实现一个或多个接口，那么父类放在最前面
委托事件作者： 574096324@qq.com |
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Weituoshijian
{
//英雄类
class Hero
{
//属性……
//private int hp;
public delegate void AttackHandler();
//攻击方法1
public void Attack(AttackHandler method)
{
method();
}
//攻击方法2
public void Attack(int index)
{
//这样写不灵活，扩展型太差
if (index==0)
{
//ToDo……
//SF.Skill_Q(); 回调
Skill_Q();
}
else if (index==1)
{
Skill_W();
}
else
{
Console.WriteLine("普通攻击" );
}
}
//一堆技能
public void Skill_Q()
{
Console.WriteLine("我正在使用Q技能" );
}
public void Skill_W()
{
Console.WriteLine("我正在使用W技能" );
}
}
//学生，玩游戏，让班长盯梢，老师来了告诉我一声
class Student
{
//接受消息
public void ReceiveMsg(string msg)
{
Console.WriteLine("我接收到消息:" + msg);
}
//让班长盯梢
public void WatchDog(Master master)
{
//老师来了回调那个方法
master.action += ReceiveMsg;
//告诉你啥？
master.msg = "老师来了" ;
}
}
class Master
{
//可以接活：事件绑定
//事件就是委托的封装,外面绑定，不能调用
public event Action< string> action;
//暗号
public string msg;
//挣钱
public void EarnMoney()
{
action(msg);
}
//盯梢
public void WatchTeacher()
{
while (true )
{
int num = int .Parse(Console.ReadLine());
if (num == 10)
{
EarnMoney();
break;
}
}
}
}
class Program
{
static void Main(string[] args)
{
////创建一个对象
//Hero SF = new Hero();
////调用攻击方法
//SF.Attack(SF.Skill_Q);
Student s = new Student();
Master m = new Master();
s.WatchDog(m);
m.WatchTeacher();
Console.ReadKey();
}
}
}
12集合作者： 574096324@qq.com |
前面的类
classMyList
{
private int [] arr = new int[10];
public int this[int index]
{
get
{
if (index >= arr.Length)
{
return 0;
}
else if (index < 0)
{
return 0;
}
else {
return arr[index];
}
}
set
{
if (index >= 0 && index < arr.Length)
{
arr[index] = value;
}
}
}
}
public static class PrintTool
{
public static void PrintStack( Stack stack)
{
foreach (object item in stack)
{
Console.WriteLine(item);
}
Console.WriteLine();
Console.WriteLine("-----------" );
}
public static void PrintQueue( Queue queue)
{
foreach (var item in queue)
{
Console.WriteLine(item);
}
Console.WriteLine("\n-----------" );
}
}
主函数里面的
//Stack 的用法：
Stack stack = new Stack();
//Push方法:往集合里添加一个元素，并且把这个元素放到顶部
stack.Push(1);
stack.Push( "lanou");
//Person p = new Person ();
//stack.Push (p);
PrintTool.PrintStack(stack);
//Pop方法：移除并返回集合顶部的对象
object popItem = stack.Pop();
Console.WriteLine("popItem:" + popItem);
PrintTool.PrintStack(stack);
//Peek方法：返回集合中顶部的对象
object peekItem = stack.Peek();
Console.WriteLine(peekItem);
PrintTool.PrintStack(stack);
//Contains:判断集合中是否存在这个元素
bool cItem = stack.Contains("lanou" );
Console.WriteLine(cItem);
//Clear:删除集合中的所有元素
stack.Clear();
PrintTool.PrintStack(stack);
//Count:返回集合中当前元素个数
int count = stack.Count;
Console.WriteLine(count);
stack.Push(1);
//Colne:
int[] a = { 1, 2, 3, 4 };
int[] b;
b = ( int[])a.Clone();
b[0] = 2;
foreach (var item in b)
{
Console.WriteLine(item);
}
Console.WriteLine(a.Equals(b));
//Queue:队列， 先进先出
Queue queue = new Queue();
//Enqueue: 将一个元素放入集合的尾部
queue.Enqueue(1);
queue.Enqueue( "lanou");
queue.Enqueue(1.5);
queue.Enqueue(5.0f);
PrintTool.PrintQueue(queue);
//Dequeue: 将集合首个元素删除，并返回
object deItem = queue.Dequeue();
Console.WriteLine(deItem);
PrintTool.PrintQueue(queue);
//Add:往集合中添加指定的键、值元素
Dictionary<int , string> dic = new Dictionary <int, string>();
dic.Add(101, "张三");
dic.Add(102, "李四");
dic.Add(103, "李四");
foreach (var item in dic)
{
Console.WriteLine("key:" + item.Key + " value:" + item.Value);
}
Console.WriteLine("-------------" );
//TryGetValue:尝试通过键去获得值，若成功则返回true，并且将键相应的值
//通过out参数返回，否则返回false，out参数返回“”字符串
string tryItem;
bool tryResult = dic.TryGetValue(105, out tryItem);
Console.WriteLine("tryItem:" + tryItem + " tryResult:" + tryResult);
foreach (var item in dic)
{
Console.WriteLine("key:" + item.Key + " value:" + item.Value);
}
Console.WriteLine("-------------" );
//Clear:
//dic.Clear ();
foreach (var item in dic)
{
Console.WriteLine("key:" + item.Key + " value:" + item.Value);
}
Console.WriteLine("-------------" );
//Remove:删集合中指定键值
dic.Remove(102);
foreach (var item in dic)
{
Console.WriteLine(item);
}
//字典取值：可以通过［key］的方式来取的对应的值
string value = dic[101];
Console.WriteLine("101:" + value);
//ContainsKey:判断集合中是否存在某个键
bool isFindKey = dic.ContainsKey(105);
Console.WriteLine(isFindKey);
//ContainsValue: 判断集合中是否存在某个值
bool isFindValue = dic.ContainsValue("老王" );
Console.WriteLine(isFindValue);
//遍历集合中的所有键
//1. 把keys放到变量中
/*Dictionary<int ,string>.KeyCollection keys = dic.Keys;
foreach (var item in keys) {
}*/
foreach (var item in dic.Keys)
{
Console.WriteLine(item);
}
//遍历集合中的所有值
foreach (var item in dic.Values)
{
Console.WriteLine(item);
}
// 用户输入10个姓名，可以重复输入同一个姓名，
//输出每个姓名，并输出每个姓名输入的多少次。
/*Dictionary<string ,int> student = new Dictionary<string, int> ();
for (int i = 0; i < 10; i++) {
//输入一个学生的名字
string name = Console.ReadLine ();
//如果该学生已经被添加到集合中，那么将他的票数加1
if (student.ContainsKey (name)) {
student [name] += 1;
} else {//否则，加入这个学生，并且初始票数设置为1
student.Add (name , 1);
}
}
foreach (var item in student) {
Console.WriteLine (item.Key+":"+item.Value);
}*/
//--------
ArrayList arrayList = new ArrayList();
arrayList.Add(1);
arrayList.Add(2);
arrayList.Add( 'A');
arrayList.Add( "sss");
foreach (var item in arrayList)
{
Console.WriteLine(item);
}
//AddRange:可以将一个继承了ICollection接口的集合里面的
//元素挨个添加进来
//把一个字典加入的arraylist中
arrayList.AddRange(dic);
//
arrayList.AddRange(queue);
foreach (var item in arrayList)
{
Console.WriteLine(item);
}
//Contains:
arrayList.Contains( 'A');
//可以将集合中的元素通过此方法，拷贝到一个足够长的数组中
object[] arr = new object[arrayList.Count];
arrayList.CopyTo(arr);
Console.WriteLine("CopyTo---------------" );
foreach (var item in arr)
{
Console.WriteLine(item);
}
//取值方式和一维数组一样
Console.WriteLine(arrayList[0]);
MyList mylist = new MyList();
mylist[0] = 12;
Console.WriteLine(mylist[0]);
Console.ReadKey();
11接口，泛型作者： 574096324@qq.com |
1. 接口：
定义IBattle接口、声明攻击Attack()，移动Move()， 跳跃Jump()等方法；
定义IRest接口、声明SitDown()，Sleep()等方法；
定义Soldier(战士)、Master(法师)、Assassin(刺客)、Archer(弓箭手)等类，继承上述接口，并实现内部方法。
2. 定义MyList类，该类模拟一个动态数组，可以用来存放数据(以int类型为例)。实现如下功能：
1）定义属性Count，表示当前动态数组存放的int型元素个数；
2）定义方法Clear（），可以清空所有的元素；
3）定义方法Add（），可以实现添加元素的功能；
4）定义方法Insert（int value， int index）,可以实现在某个位置插入元素的功能；
5）定义方法Reverse（），可以实现元素的反转。
6）定义方法Contains（）,可以查找元素是否存在。
3. 老板招募小秘
(1)当秘书必须要实现的协议用接口IScretary表示。
要想当秘书，必须能够实现如下方法：
端茶倒水
开车
捶背
提包等
定义IBattle接口、声明攻击Attack()，移动Move()， 跳跃Jump()等方法；
定义IRest接口、声明SitDown()，Sleep()等方法；
定义Soldier(战士)、Master(法师)、Assassin(刺客)、Archer(弓箭手)等类，继承上述接口，并实现内部方法。
2. 定义MyList类，该类模拟一个动态数组，可以用来存放数据(以int类型为例)。实现如下功能：
1）定义属性Count，表示当前动态数组存放的int型元素个数；
2）定义方法Clear（），可以清空所有的元素；
3）定义方法Add（），可以实现添加元素的功能；
4）定义方法Insert（int value， int index）,可以实现在某个位置插入元素的功能；
5）定义方法Reverse（），可以实现元素的反转。
6）定义方法Contains（）,可以查找元素是否存在。
3. 老板招募小秘
(1)当秘书必须要实现的协议用接口IScretary表示。
要想当秘书，必须能够实现如下方法：
端茶倒水
开车
捶背
提包等
(2)有两类人前来应聘秘书：
男人类 Man
女人类 Woman
机器人类 Robot
请让以上三个类继承秘书协议，并根据每个类的特点实现协议中的方法
女人类 Woman
机器人类 Robot
请让以上三个类继承秘书协议，并根据每个类的特点实现协议中的方法
(3)在Main方法中分别创建男秘对象和女秘对象，并自行设计模拟情景。
如：有一天老板招了一个男秘，让他干这干那，后来不满意，又招了一个女秘...
再后来科技突飞猛进，老板雇佣了一个不知疲倦聪明又从来不抱怨的机器秘书
2.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
/*2. 定义MyList类，该类模拟一个动态数组，可以用来存放数据(以int类型为例)。实现如下功能：
1）定义属性Count，表示当前动态数组存放的int型元素个数；
2）定义方法Clear（），可以清空所有的元素；
3）定义方法Add（），可以实现添加元素的功能；
4）定义方法Insert（int value， int index）,可以实现在某个位置插入元素的功能；
5）定义方法Reverse（），可以实现元素的反转。
6）定义方法Contains（）,可以查找元素是否存在。 */
namespace h2
{
interface IInterface
{
}
class MyList< T>
{
//该字段用来记录数组里面所放元素的个数
private int length;
//用来记录数组的容量，即最多可放元素的个数
private int capacity;
//数组用来存取数据
private T [] a;
//在默认构造方法里面给字段赋初值
public MyList()
{
//数组元素的个数初始值为0
length = 0;
//数组容量初始值为8
capacity = 8;
//给数组开辟空间
a = new T [capacity];
}
/// <summary>
/// 属性，得到数组的元素的个数
/// </summary>
public int Count
{
get
{
return length;
}
}
public void Add(T x)
{
//先判断数组的容量是否可以再返给数据
if (length>=capacity)
{
//如果不能再放入数据，扩充数组容量
}
//把要加的数据方法放到数组里面
a[length] = x;
//数组元素的个数要加1
length++;
}
/// <summary>
/// 扩充数组容量的方法
/// </summary>
private void EnlargeCapacity()
{
//把容量值增加
capacity += 8;
//根据增加后的容量创建新数组
T[] temp = new T[capacity];
//把a数组里面的元素复制到新数组里面
for (int i = 0; i < length; i++)
{
temp[i] = a[i];
}
//把a指向新数组
a =temp;
}
/// <summary>
/// 清空数组
/// </summary>
public void Clear()
{
//数组元素为0
length = 0;
//数组容量为8
capacity = 8;
//创建一个新的数组
a = new T [capacity];
}
public bool Contains(int x)
{
for (int i = 0; i < length; i++)
{
if (x.Equals(a[i]))
{
return true ;
}
}
return false ;
}
//数组的反转
public void Reverse()
{
for (int i = 0; i < length/2; i++)
{
T temp = a[i];
a[i] = a[length - 1 - i];
a[length - 1 - i] = temp;
}
}
/// <summary>
/// 插入
/// </summary>
/// <param name=" index"></param>
/// <param name=" num"></param>
public void Insert(int index, T num)
{
if (length>=capacity)
{
EnlargeCapacity();
}
//如果插入的位置在数组之外
if (index<0)
{
Console.WriteLine("index不能小于0" );
return;
}
//如果插入的位置刚好在所有元素的最后面
else if (index ==length)
{
a[index]= num;
length += 1;
}
else if (index >= length + 1)
{
}
else
{
//把数组里面index之后的所有元素往后面移动一位
for (int i = length-1; i >=index; i--)
{
a[i + 1] = a[i];
}
a[index] = num;
length += 1;
}
}
/// <summary>
/// 打印数组
/// </summary>
public void PrintArray()
{
//使用for循环把存到数组a里面的元素打印出来
for (int i = 0; i < length; i++)
{
Console.WriteLine(a[i]);
}
}
}
class Program
{
static void Main(string[] args)
{
MyList<int > list = new MyList< int>();
list.Add(5);
list.Add(6);
list.Add(7);
list.PrintArray();
list.Insert(1, 9);
list.PrintArray();
Console.ReadKey();
}
}
}
10作业作者： 574096324@qq.com |
课后题：
第一题 定义一个打印机类（printer）。需求：
1. 采用单例模式
2. 定义成员变量：打印机IP地址（静态变量），打印数量，纸张类型（数值为枚举类型）
3. 定义方法：根据打印机IP地址连接打印机；打印功能；打印失败提醒功能
第二题 模拟打僵尸。需求：
定义僵尸类：
公共成员变量：类型、总血量、每次失血量
方法：初始化方法(设置僵尸种类，总血量)、被打击失血（抽象方法）、死亡（抽象方法）
定义普通僵尸类继承于僵尸类
定义有防具(路障)僵尸类继承于僵尸类：
特有成员变量：防具类型
特有方法：防具被打烂
定义铁桶僵尸类继承于有防具僵尸：
特有成员变量：弱点
特有方法：防具被磁铁吸走
1、创建普通僵尸对象，设置总血量50，每次失血量为 3
2、创建路障僵尸对象，设置总血量80，有路障时，每次失血量为 2
3、创建铁桶僵尸对象，设置总血量120，有铁桶时，每次失血量为 1
4、选作：
在Main方法里面里用循环语句模拟攻击：
第一题 定义一个打印机类（printer）。需求：
1. 采用单例模式
2. 定义成员变量：打印机IP地址（静态变量），打印数量，纸张类型（数值为枚举类型）
3. 定义方法：根据打印机IP地址连接打印机；打印功能；打印失败提醒功能
第二题 模拟打僵尸。需求：
定义僵尸类：
公共成员变量：类型、总血量、每次失血量
方法：初始化方法(设置僵尸种类，总血量)、被打击失血（抽象方法）、死亡（抽象方法）
定义普通僵尸类继承于僵尸类
定义有防具(路障)僵尸类继承于僵尸类：
特有成员变量：防具类型
特有方法：防具被打烂
定义铁桶僵尸类继承于有防具僵尸：
特有成员变量：弱点
特有方法：防具被磁铁吸走
1、创建普通僵尸对象，设置总血量50，每次失血量为 3
2、创建路障僵尸对象，设置总血量80，有路障时，每次失血量为 2
3、创建铁桶僵尸对象，设置总血量120，有铁桶时，每次失血量为 1
4、选作：
在Main方法里面里用循环语句模拟攻击：
三个僵尸对象同时被攻击：
(1)、普通僵尸被打击时：每次失血3.
(2)、路障僵尸被打击时：有路障时，每次失血2，血量剩余一半时，防具被打拦，之后每次失血3.
(3)、铁桶僵尸被打击时：有铁桶时，每次失血1，血量剩余1/3时，铁桶被打拦，之后每次失血3.
循环攻击过程中：每个僵尸被攻击时，输出本次丢失血量，剩余血量。失去道具时，输出丢失的道具。僵尸死亡时，输出已死亡。
(2)、路障僵尸被打击时：有路障时，每次失血2，血量剩余一半时，防具被打拦，之后每次失血3.
(3)、铁桶僵尸被打击时：有铁桶时，每次失血1，血量剩余1/3时，铁桶被打拦，之后每次失血3.
循环攻击过程中：每个僵尸被攻击时，输出本次丢失血量，剩余血量。失去道具时，输出丢失的道具。僵尸死亡时，输出已死亡。
最后一个僵尸死亡时，攻击停止，循环结束。输出总攻击次数。
/*------------------------------------------------------*/
打僵尸
using System;
namespace Zombie
{
//创建僵尸的基类,把共有的字段和方法写在基类里面
//子类就可以直接调用或者重写方法
class Zombie
{
//血量
public int HP { get; set; }
//失血量
public int LP { get; set; }
//虚方法,由子类重写,如果子类不重写,则调用父类
//里面的方法,如普通僵尸就是调用的父类里面的方法
public virtual void BeAttacked()
{
//打印血量的值
Console.WriteLine("僵尸的血量hp:" + HP);
//血量减去失血量
HP -= LP;
//如果血量小于或者等于0
if (HP <= 0)
{
HP = 0;
//调用死亡的方法
Die();
}
}
//虚方法,当僵尸的血量小于或者等于0时调用该方法
public virtual void Die()
{
Console.WriteLine("僵尸死亡" );
}
}
//普通僵尸继承僵尸的基类,所有的方法都是调用的基类的
class Normal : Zombie
{
//给普通僵尸字段初始化
public Normal(int hp, int lp)
: base()
{
this.HP = hp;
this.LP = lp;
}
}
//定义路障僵尸类继承于僵尸类
class RoadBlock : Zombie
{
public RoadBlock()
{
}
//初始化赋值,用带参数的构造方法
public RoadBlock(int hp, int lp, bool haveRoad)
: base()
{
this.HP = hp;
this.LP = lp;
this.haveRoadBlock = haveRoad;
}
//该字段是受保护的,只能在子类和父类内部使用
//字段的含义是是否有路障,初始值为true
protected bool haveRoadBlock;
//重写被攻击的方法
public override void BeAttacked()
{
Console.WriteLine("路障僵尸血量:" + this.HP);
//血量减去失血量
this.HP -= this .LP;
//当血量小于或者等于总血量的一半时
if (this .HP <= 40)
{
//路障丢失,调用路障丢失的方法
DefenceLost();
}
//如果没有路障,则把失血量改为3
if (haveRoadBlock == false )
{
this.LP = 3;
}
//如果血量小于0,调用死亡的方法
if (this .HP <= 0)
{
this.HP = 0;
Die();
}
}
//虚方法,子类进行重写,丢失路障的方法
public virtual void DefenceLost()
{
haveRoadBlock = false;
Console.WriteLine("丢失路障" );
}
//重写了父类里面的虚方法
public override void Die()
{
Console.WriteLine("路障僵尸死亡" );
}
}
//铁桶僵尸继承路障僵尸
class Bucket : RoadBlock
{
//初始化
public Bucket(int hp, int lp, bool haveBucket)
: base()
{
this.HP = hp;
this.LP = lp;
this.haveRoadBlock = haveBucket;
}
//重写了受到攻击的方法
public override void BeAttacked()
{
Console.WriteLine("铁桶僵尸的血量:" + this.HP);
this.HP -= this .LP;
if (this .HP <= 40)
{
DefenceLost();
}
if (haveRoadBlock == false )
{
this.LP = 3;
}
if (this .HP <= 0)
{
this.HP = 0;
Die();
}
}
public override void Die()
{
Console.WriteLine("铁桶僵尸死亡" );
}
}
class MainClass
{
public static void Main( string[] args)
{
Normal normal = new Normal(50, 3);
RoadBlock road = new RoadBlock(80, 2, true);
Bucket bucket = new Bucket(120, 1, true);
int num = 1;
do
{
Console.WriteLine("第{0}回合" , num);
num++;
normal.BeAttacked();
road.BeAttacked();
bucket.BeAttacked();
//如果三种僵尸的血量都小于0,跳出循环
if (normal.HP <= 0 && road.HP <= 0 && bucket.HP <= 0)
{
break;
}
} while (true );
Console.ReadKey();
}
}
}
09作业作者： 574096324@qq.com |
1.（＊＊）定义一个矩形类（Rectangle），
成员变量：width,height,
XYPoint类型的point（原始点），
XYPoint类型的center（中心点）。
方法：封装变量为属性，构造方法初始化成员变量，
计算周长、计算面积（ref/out参数修饰）
2. (＊＊) 定义玩家类(Player)，并创建玩家对象
(1) 包含属性：出生日期、星座
(2) 构造方法：根据玩家出生日期设置星座
（提示：星座设置可参考第二讲作业）
3. (**) 定义如下类
装备类：
特征：名称
武器类 继承 装备类：
特征：等级、攻击力
行为：攻击
法杖类 继承 武器类：
行为：远程魔法攻击（实现方法替换）
弓箭类 继承 武器类：
行为：远程物理攻击（实现方法替换）
长剑类 继承 武器类：
独有特征：防御力
行为：进展物理攻击（实现方法替换）
防具类 继承 装备类：
特征：防御力、耐久度
行为：破损
4. （＊＊＊）
成员变量：width,height,
XYPoint类型的point（原始点），
XYPoint类型的center（中心点）。
方法：封装变量为属性，构造方法初始化成员变量，
计算周长、计算面积（ref/out参数修饰）
2. (＊＊) 定义玩家类(Player)，并创建玩家对象
(1) 包含属性：出生日期、星座
(2) 构造方法：根据玩家出生日期设置星座
（提示：星座设置可参考第二讲作业）
3. (**) 定义如下类
装备类：
特征：名称
武器类 继承 装备类：
特征：等级、攻击力
行为：攻击
法杖类 继承 武器类：
行为：远程魔法攻击（实现方法替换）
弓箭类 继承 武器类：
行为：远程物理攻击（实现方法替换）
长剑类 继承 武器类：
独有特征：防御力
行为：进展物理攻击（实现方法替换）
防具类 继承 装备类：
特征：防御力、耐久度
行为：破损
4. （＊＊＊）
按如下继承关系定义类
要求：
1. 每个类包含2个以上私有成员变量、保护成员变量
2. 每个类所有字段都封装成属性
3. 每个类至少有一个属性为只读和只写
4. 每个类有两个以上初始化方法
5. 动物类有一个移动的方法(move)，子类重写（重新实现）该方法
6. 为哺乳类添加特有的虚方法(sayHi)，子类重写该方法
7. 其它方法可以尽情发挥
8. 在Main方法中创建各个类的对象，调用类的方法
5.(***) 定义英雄类和Boss类，创建3个英雄对象，分别拿不同的武器（用第三题的类创建），对敌人循环回合制攻击，输出战斗过程。
英雄类：
特征：HP、MP、类型（枚举类型：弓箭手、法师、骑士）、武器（用第一题定义的类）
行为：攻击、防御
Boss类：
特征：HP、攻击力、防御力
行为：攻击
要求：
1. 每个类包含2个以上私有成员变量、保护成员变量
2. 每个类所有字段都封装成属性
3. 每个类至少有一个属性为只读和只写
4. 每个类有两个以上初始化方法
5. 动物类有一个移动的方法(move)，子类重写（重新实现）该方法
6. 为哺乳类添加特有的虚方法(sayHi)，子类重写该方法
7. 其它方法可以尽情发挥
8. 在Main方法中创建各个类的对象，调用类的方法
5.(***) 定义英雄类和Boss类，创建3个英雄对象，分别拿不同的武器（用第三题的类创建），对敌人循环回合制攻击，输出战斗过程。
英雄类：
特征：HP、MP、类型（枚举类型：弓箭手、法师、骑士）、武器（用第一题定义的类）
行为：攻击、防御
Boss类：
特征：HP、攻击力、防御力
行为：攻击
（提示：以上各个类及其特征和行为可以自行设计丰富，为项目期做储备）
09面向对象作者： 574096324@qq.com |
构造方法
构造方法，是与类名相同，并且无返回值，不加void
构造方法的主要作用是创建对象并给对象赋初值
不带有参数的构造方法称为默认构造
构造方法可以带有参数进行重载, 如果要给对象赋具体的初始值时
可以在类里面写出带有参数的构造方法并调用
如果在类里面没有构造方法，当我们创建对象时，系统会自动生成一个默认构造供使用
如果类里面有带有参数的构造方法，调用默认构造时，必须显示的把默认构造写出来
面向对象三大特性：封装、继承、多态
封装
我们在创建对象时，不希望外部人为的来破坏对象所包含的字段的值，此时就需要把数据封装起来
具体的做法是：把成员字段用private字段修饰，这样外部就无法拿到字段并修改所存储的数据
同时把私有的字段改成属性，通过属性来修改字段的值，创建对象并初始化对象时
可以用带有参数的构造方法给字段赋初始值，把字段写成私有后，虽然在外部不能使用，但是在类的内部可以使用、
即类内部的方法可以调用类里面的私有字段
继承
当一个子类继承父类，会把父类里面的成员继承过来，
父类里面的成员如果用public修饰，称为共有继承，用private修饰称为私有继承
公有继承的成员在任何地方都能使用
私有继承过来的成员只能在分类内部使用，在类的额外面不能使用
protected继承过来的成员只能在父类和子类里面使用，类的外面不能使用
//里氏转换
SmallDog small = new SmallDog();
BigDog big = new BigDog();
stu.WalkDog(big);
stu.WalkDog(small);
//在处理数据时，为了使所处理的数据，类型达到统一，
//此时会把数据的类型统一写成父类的类型，这样就可以吧子类的对象直接赋值给父类
//里氏转换的第一个原则：把子类对象赋值给父类，但是调用类里面的成员时只能调用父类里面的子类里面的调用不到
Dog dog = small;
//里氏转换的第二个原则;把父类的对象转成子类,as
BigDog s =dog as BigDog;
if (s!=null )
{
s.BigDogBark();
}
//把值类型转换成引用类型的过程称为装箱
object obj = a;
Console.WriteLine(obj);
//把引用类型转换成值类型称为拆箱
int c=(int )obj;
多态
virtual override
08作业作者： 574096324@qq.com |
1. （＊＊）输入一个字符串，”beijinglanoukeji,lanoukeji is great, I love lanou and unity”,，完成如下要求：
（1）判断字符串是否存在lanou,如果存在lanou则输出第一个坐标；
（2）将字符串中出现的所有lanou替换为lanou3g,并输出最后一个lanou3g的坐标；
（3）讲字符串改为大写输出出来；
（4）判断字符串是否存在“,”，若存在则按字符串“,”分组，输出字符串数组长度，输出所有字符串。
2. (**)定义一个计算器(Computer)类：
包含方法：
(1) 返回两个数的最大值
(2) 返回三个数的最大值
(3) 返回两个数的最小值
(4) 返回三个数的最小值
(5) 返回两个数的和
(6) 返回三个数的和
…… (可以自由扩展和完善这个类) ……
3.(＊＊＊)有一个GET网络请求中，网络连接(url字符串)通常是如下形式：
![]()
http://msdn.microsoft.com/zh-CN/?query=string
其中?后面表示参数。上面的例子中，参数名为query的参数值为string
(1) 判断一个字符串是否是合法的url字符串(以http://或https://开头)
(2) 判断网络连接中是否包含参数(提示：通过是否有?判断)
（1）判断字符串是否存在lanou,如果存在lanou则输出第一个坐标；
（2）将字符串中出现的所有lanou替换为lanou3g,并输出最后一个lanou3g的坐标；
（3）讲字符串改为大写输出出来；
（4）判断字符串是否存在“,”，若存在则按字符串“,”分组，输出字符串数组长度，输出所有字符串。
2. (**)定义一个计算器(Computer)类：
包含方法：
(1) 返回两个数的最大值
(2) 返回三个数的最大值
(3) 返回两个数的最小值
(4) 返回三个数的最小值
(5) 返回两个数的和
(6) 返回三个数的和
…… (可以自由扩展和完善这个类) ……
3.(＊＊＊)有一个GET网络请求中，网络连接(url字符串)通常是如下形式：
其中?后面表示参数。上面的例子中，参数名为query的参数值为string
(1) 判断一个字符串是否是合法的url字符串(以http://或https://开头)
(2) 判断网络连接中是否包含参数(提示：通过是否有?判断)
4.（＊＊**）楼梯有N（小于50的整数）阶，上楼可以一步上一价，也可以一(3) 封装一个方法，输入url字符串，返回其参数名和参数值
次上二阶。编一个程序，计算共有多少种不同的走法。(递归实现)
5.（＊＊）编写一个GameObject类，写一个GetComponent()方法，要求实现两个以上的重载方法，一个参数为string类型，一个参数为自定义枚举类型。方法返回值为string类型，返回一句话，说明调用的是什么方法，参数值是什么。
07作业作者： 574096324@qq.com |
1. （＊＊）定义分数（Fraction）类：
1）、成员变量
私有字段以及可读可写属性：分子、分母
2）、成员方法：
（1）打印分数信息（例如： 1 / 3）
（2）约分
（3）创建一个方法交换分子和分母的值
(4)创建一个方法能同时得到加、减、乘、除、求余运算;
2. （＊＊） 定义一个Car类，用成员变量表示品牌，当前速度，最大速度和方向（假设有东南西北四个方向），为其添加显示速度、显示方向、加速、减速以及转盘（可以向左转向右转）方法
在Main方法中创建Car类对象，并调用其方法
提示：汽车的当前方向（东南西北）以及转盘转向（左右）可以分别用两个枚举表示。每次加速减速的值为定值，速度不能为负值，也不能超过最大速度。
3. （＊＊）定义几何类Geometry
用一个方法同时计算矩形的面积和体积，并同时返回它的面积和体积
4.（＊＊）买房是大事：
1) 创建两个类，模拟生活中房屋和人的特征和行为。
房屋类：
特征：房东、地址、面积、每平米价格
行为：估价、升值等
（提示：房屋的房东是人类；估价返回 面积*每平米价格；升值改变 每平米价格）
人类：
特征：姓名、性别、钱、配偶、房子
行为：工作挣钱、买房子、结婚、卖房子、离婚等
（提示：人类的配偶是人类；买房子的参数是房子类）
(2) 在Main方法中运用以上两个类创建（实力化）对象模拟以下情景：
一个人工作挣钱，有一天终于攒够了钱，买了一个房子，然后找了一个对象结婚。
后来婚姻出现了第三者，两人离婚后此人卖掉了房子，最终和第三者结婚。
/*4.（＊＊）买房是大事：
1) 创建两个类，模拟生活中房屋和人的特征和行为。
房屋类：
特征：房东、地址、面积、每平米价格
行为：估价、升值等
（提示：房屋的房东是人类；估价返回 面积*每平米价格；升值改变 每平米价格）
人类：
特征：姓名、性别、钱、配偶、房子
行为：工作挣钱、买房子、结婚、卖房子、离婚等
（提示：人类的配偶是人类；买房子的参数是房子类）
(2) 在Main方法中运用以上两个类创建（实力化）对象模拟以下情景：
一个人工作挣钱，有一天终于攒够了钱，买了一个房子，然后找了一个对象结婚。
后来婚姻出现了第三者，两人离婚后此人卖掉了房子，最终和第三者结婚。
*/
namespace BuyHouse
{
enum Sex
{
男,女
}
class Person
{
public string Name { get; set; } //姓名，属性
public Sex PersonSex { get; set; } //性别，属性
public double Money { get; set; } //钱，属性
public Person Mate { get; set; } //配偶，属性
public House PersonHouse { get; set; } //房子，属性
public void PersonInit(string name, Sex sex, double money, Person mate, House house)
{
Name = name;
PersonSex = sex;
Money = money;
Mate = mate;
PersonHouse = house;
}
/// <summary>
/// 挣钱
/// </summary>
/// <param name=" m"></param>
public void EarnMoney(double m)
{
Money += m;
Console.WriteLine("你当前的存款为:{0}" ,Money);
}
/// <summary>
/// 买房子
/// </summary>
public void BuyHouse(House house)
{
//存款大于等于房子总价格
if (Money>=house.TotalPrice)
{
house.Host = this;//this调用的
Console.WriteLine("你买到了房子，房东是:{0}" ,this.Name);
//房子买到了，存款减去房子总价格
PersonHouse = house;
Money -= house.TotalPrice;
}
else
{
Console.WriteLine("你的存款不够，需要挣钱买房子" );
}
}
public void Marry(Person girl)
{
if (PersonHouse==null )
{
Console.WriteLine("房子都没有，不能结婚" );
}
else
{
Mate = girl;
girl.Mate = this;
Console.WriteLine("我结婚了，配偶的名字是:{0}" ,girl.Name);
}
}
public void SaleHouse()
{
Console.WriteLine("把房子卖了" );
Money += PersonHouse.TotalPrice;
PersonHouse.Host = null;
PersonHouse = null;
Console.WriteLine("卖房后的存款为:{0}" ,Money);
}
public void Divorce()
{
this.Mate.Mate = null ;
Mate = null;
Console.WriteLine("离婚了，做个单身狗" );
}
}
class House
{
public Person Host { get; set; } //房东，属性
public string Address { get; set; } //地址，属性
public double Area { get; set; } //面积，属性
public double Price { get; set; } //价格，属性
/// <summary>
/// 初始化房子
/// </summary>
/// <param name=" host"></param>
/// <param name=" add"></param>
/// <param name=" area"></param>
/// <param name=" pri"></param>
public void HouseInit(Person host, string add,double area,double price)
{
Host = host;
Address = add;
Price = price;
Area = area;
}
public double TotalPrice { get; set; } //房子总价
/// <summary>
/// 给房子估价
/// </summary>
public void Evaluate()
{
TotalPrice = Area * Price;
}
/// <summary>
/// 房价升值
/// </summary>
/// <param name=" up"></param>
public void PriceUp(double up)
{
Price = up;
}
}
class Program
{
static void Main(string[] args)
{
House house = new House();
house.HouseInit( null, "清河" , 100.4, 7.5);
Person lilei = new Person();
lilei.PersonInit( "李雷",Sex .男,0,null,null);
Person hanmeimei = new Person();
hanmeimei.PersonInit( "韩梅梅" , Sex.女, 0, null, null );
lilei.BuyHouse(house);
house.Evaluate();
lilei.BuyHouse(house);
lilei.EarnMoney(400);
lilei.Marry(hanmeimei);
lilei.BuyHouse(house);
lilei.EarnMoney(400);
lilei.BuyHouse(house);
lilei.Marry(hanmeimei);
house.PriceUp(8);
house.Evaluate();
lilei.SaleHouse();
lilei.Divorce();
Console.ReadKey();
}
}
}
作业，类 对象方法作者： 574096324@qq.com |
1.（*）完成课件的练习，建30个类，每个类有自己的特征，为特征填写Get 方法和Set方法。
2. （＊＊＊）完成蓝鸥班级开班仪式流程：
1、早9：30开班仪式开始。（输出(“开班仪式正式开始”)）2、刘辉老师做自我介绍。3、三名学生做自我介绍。
需求：
(1)定义一个班级类。
成员：所属培训机构名称，班级名，班级人数、授课老师名字、开班日期。
方法：初始化(设置学校名字：蓝鸥)、集体活动、开班仪式。
(2)定义一个老师类。
成员：名字、性别、年龄、正在教的课程、正在授课班级。
方法：初始化、讲课、布置作业、验收作业、解决问题、自我介绍。
(3)定义一个学生类。
成员：名字、性别、年龄、学号、班级名、任课老师、正在学习的课程。
方法：初始化、学习、做作业、提出问题、回答问题、自我介绍。
3.(**)创建一个方法,功能是把一个int类型的数组拷贝到另外一个数组里面,并把数组各元素打印出来;
4.(**)创建一个方法,求一个int类型数组里面元素的和,并把和打印出来;
2. （＊＊＊）完成蓝鸥班级开班仪式流程：
1、早9：30开班仪式开始。（输出(“开班仪式正式开始”)）2、刘辉老师做自我介绍。3、三名学生做自我介绍。
需求：
(1)定义一个班级类。
成员：所属培训机构名称，班级名，班级人数、授课老师名字、开班日期。
方法：初始化(设置学校名字：蓝鸥)、集体活动、开班仪式。
(2)定义一个老师类。
成员：名字、性别、年龄、正在教的课程、正在授课班级。
方法：初始化、讲课、布置作业、验收作业、解决问题、自我介绍。
(3)定义一个学生类。
成员：名字、性别、年龄、学号、班级名、任课老师、正在学习的课程。
方法：初始化、学习、做作业、提出问题、回答问题、自我介绍。
3.(**)创建一个方法,功能是把一个int类型的数组拷贝到另外一个数组里面,并把数组各元素打印出来;
4.(**)创建一个方法,求一个int类型数组里面元素的和,并把和打印出来;
类和面向对象编程作者： 574096324@qq.com |
类，对象，类成员：字段、方法
//用类创建一个对象，用new运算符，类里面用来描述特征的变量称为这个类的字段
////使用对象调用字段时，用点运算符得到字段并赋值，
////如果在类外部使用字段时，字段一定用public修饰
//car.color = "red";
//car.price = 100.5;
//car.type = "BMW";
////用点运算符点出来的成员，前面如果是
////F表示的是字段(field),M表示的是方法,C表示类，E表示枚举,S代表结构体，
////D表示委托，I表示接口，'{'表示名字空间，P表示属性
////API)(Application Program Interface)应用程序开发接口
作业作者： 574096324@qq.com |
1. （***）定义一个枚举类型PlayerStatus（包括：跑run，跳jump，下滑sliding，左转弯turnLeft，右转弯turnRight），用来表示玩家的动作，结合switch/case语句使用，写一个小程序:按W跑,空格跳,S下滑,A左转弯,D右转变.
2. （＊）定义一个枚举类型PrimitiveType（包括：正方体 cube，球体 sphere，胶囊体 capsule，圆柱体cylinder，平面plane，四边形quad），用来存在常用的游戏物体。定义一个枚举变量并赋值，输出其默认的整型值。
3. （＊＊）结构体排序：定义一个结构体Vector3(包括x,y,z三个公共成员变量，float类型)，声明3个结构体变量，按照x由小到大得排序规则（x相同的则按照y排，y相同则按照z排序），依次输出三个变量。
4. （＊＊＊）某班有5个学生，三门课（数学，英语和语文）。分别实现以下要求：
（1） 求各门课的平均分；
（2） 找出有两门以上不及格的学生，并输出其学号和不及格课程的成绩；
（3） 找出三门课平均成绩在85-90分的学生，并输出其学号和姓名 ；
（4）按成绩对学生进行降序排序，如果数学成绩相等，按英语成绩排序，如果英语成绩相等，按语文成绩排序；
5.（＊＊）用枚举表示网购订单状态，输入推进状态数，模拟订单进展过程，并显示最终状态。订单状态参考： 未确认,已确认,已取消,无效,未发货,已发货,未付款,已付款,退货,确认收货,完成。
6. （＊＊）创建一个英雄结构体变量，成员包含英雄当前状态。
英雄的可以有名字，HP，MP等属性
7. （＊＊＊）用结构体数组创建创建两个战队（每队5人），为每个英雄赋随机属性，合算综合战斗力并输出
2. （＊）定义一个枚举类型PrimitiveType（包括：正方体 cube，球体 sphere，胶囊体 capsule，圆柱体cylinder，平面plane，四边形quad），用来存在常用的游戏物体。定义一个枚举变量并赋值，输出其默认的整型值。
3. （＊＊）结构体排序：定义一个结构体Vector3(包括x,y,z三个公共成员变量，float类型)，声明3个结构体变量，按照x由小到大得排序规则（x相同的则按照y排，y相同则按照z排序），依次输出三个变量。
4. （＊＊＊）某班有5个学生，三门课（数学，英语和语文）。分别实现以下要求：
（1） 求各门课的平均分；
（2） 找出有两门以上不及格的学生，并输出其学号和不及格课程的成绩；
（3） 找出三门课平均成绩在85-90分的学生，并输出其学号和姓名 ；
（4）按成绩对学生进行降序排序，如果数学成绩相等，按英语成绩排序，如果英语成绩相等，按语文成绩排序；
5.（＊＊）用枚举表示网购订单状态，输入推进状态数，模拟订单进展过程，并显示最终状态。订单状态参考： 未确认,已确认,已取消,无效,未发货,已发货,未付款,已付款,退货,确认收货,完成。
6. （＊＊）创建一个英雄结构体变量，成员包含英雄当前状态。
英雄的可以有名字，HP，MP等属性
7. （＊＊＊）用结构体数组创建创建两个战队（每队5人），为每个英雄赋随机属性，合算综合战斗力并输出
提示：战斗力可以是平均等级，攻击力，血量等等。也可以是由这些数值构成的一个综合表达式
using System;
namespace 第05课件
{
class MainClass
{
//课堂练习1的枚举
enum Action
{
Run = 1,
Jump,
Idel = 4,
Attack,
}
//课堂练习2的枚举
enum GameStatus
{
//开始
Start,
//暂停
Pause,
//结束
Over
}
//课堂练习3的结构体
public struct StudentInfor
{
public string name;
public int age;
public int number;
}
//课后作业1的枚举
enum PlayerStatus
{
run = 119,
jump = 32,
sliding = 115,
turnLeft = 97,
turnRight = 100
}
//课后作业2的枚举
enum PrimitiveType
{
//正方体
cube = 6,
//球体
sphere = 0,
//胶囊体
capsule = 1,
//圆柱体
cylinder = 2,
//平面
plane = 5,
//四边形
quad = 4
}
//课后作业3的结构 体
struct Vector3
{
public float x;
public float y;
public float z;
}
//课后作业4的结构体
struct Student
{
public string name;
public int number;
public float math;
public float english;
public float music;
}
//课后作业5的枚举
enum ShoppingStatus
{
未确认,
已确认,
已取消,
无效,
未发货,
已发货,
未付款,
已付款,
退货,
确认收货,
完成订单
}
//课后作业6的结构体
struct Hero
{
public string name;
public int HP;
public int MP;
public PlayerStatus status;
}
//课后作业7的结构体
struct HeroAttackValue
{
public int attack;
}
public static void Main( string[] args)
{
/*
//课堂练习1:创建枚举,表⽰一个人体的各类动作,并赋予其不同的内部整数值,观察其他枚举直接量内部整数值的变化。
//以枚举Action为例,把Jump和Attack的值打印出来
Action a = Action.Jump;
int n1 = (int)a;
Console.WriteLine ("Jump的值是:{0}",n1);
Action b = Action.Attack;
int n2 = (int)b;
Console.WriteLine ("Jump的值是:{0}",n2);
*/
//课堂练习2:创建枚举,表⽰示游戏的所有状态(开始游戏、暂停游戏、结束游戏)
//答案见上面
/*
//课堂练习3:创建学⽣生结构体,包含姓名、年龄、学号等信息,并赋予其值,输出结构体成员的值。
StudentInfor stu1;
stu1.name = "张三";
stu1.age = 24;
stu1.number = 20140101;
Console.WriteLine ("学生的姓名:{0},年龄:{1},学号:{2}",stu1.name,stu1.age,stu1.number);
*/
/*
//课后作业1:定义一个枚举类型PlayerStatus（包括：跑run，跳jump，下滑sliding，
//左转弯turnLeft，右转弯turnRight），用来表示玩家的动作，结合switch/case语句使用，写一个小程序
do {
Console.WriteLine ("请按下相应的键:(a向左,d向右,s滑动,w跑,空格跳)");
Console.Write("\n");
PlayerStatus p = (PlayerStatus)Console.Read();
switch(p){
case PlayerStatus.run :
{
Console.WriteLine("跑");
break;
}
case PlayerStatus.jump :
{
Console.WriteLine("跳");
break;
}
case PlayerStatus.sliding :
{
Console.WriteLine("滑动");
break;
}
case PlayerStatus.turnLeft :
{
Console.WriteLine("左转");
break;
}
case PlayerStatus.turnRight :
{
Console.WriteLine("右转");
break;
}
default:
{
Console.WriteLine("退出");
break;
}
}
} while(true);
*/
/*
//课后作业2:定义一个枚举类型PrimitiveType（包括：正方体 cube，球体 sphere，胶囊体 capsule，
//圆柱体cylinder，平面plane，四边形quad），用来存在常用的游戏物体。定义一个枚举变量并赋值，
//输出其默认的整型值。
Console.WriteLine ("正方体的值为:{0}",(int)PrimitiveType.cube);
Console.WriteLine ("球体的值为:{0}",(int)PrimitiveType.sphere);
Console.WriteLine ("胶囊体的值为:{0}",(int)PrimitiveType.capsule);
Console.WriteLine ("圆柱体的值为:{0}",(int)PrimitiveType.cylinder);
Console.WriteLine ("平面的值为:{0}",(int)PrimitiveType.plane);
Console.WriteLine ("四边形的值为:{0}",(int)PrimitiveType.quad);
*/
/*
//课后作业3:结构体排序：定义一个结构体Vector3(包括x,y,z三个公共成员变量，float类型)，
//声明3个结构体变量，按照x由小到大得排序规则（x相同的则按照y排，y相同则按照z排序），
//依次输出三个变量。
//定义三个结构体变量,分别赋值
Vector3 vec1;
vec1.x = 12;
vec1.y = 13;
vec1.z = 35;
Vector3 vec2;
vec2.x = 45;
vec2.y = 14;
vec2.z = 34;
Vector3 vec3;
vec3.x = 45;
vec3.y = 23;
vec3.z = 25;
//把结构体放到数组里面进行冒泡排序,只是比较数据的时候用的是结构体里面的成员
Vector3[] v = { vec1, vec2, vec3 };
for (int i = 0; i < v.Length; i++) {
for (int j = 0; j < v.Length - i - 1; j++) {
//数组元素是一个结构体,得到数组元素的值后,再访问结构体里面的成员数据
//然后用成员数据进行比较
if (v [j].x < v [j + 1].x) {
Vector3 temp = v [j];
v [j] = v [j + 1];
v [j + 1] = temp;
}
if (v [j].x == v [j + 1].x) {
if (v [j].y < v [j + 1].y) {
Vector3 temp1 = v [j];
v [j] = v [j + 1];
v [j + 1] = temp1;
}
if (v [j].y == v [j + 1].y) {
if (v [j].z < v [j + 1].z) {
Vector3 temp2 = v [j];
v [j] = v [j + 1];
v [j + 1] = temp2;
}
}
}
}
}
//把排序后的结构体数据打印出来
for (int i = 0; i < 3; i++) {
Console.Write ("{0},{1},{2}\n", v [i].x, v [i].y, v [i].z);
}
*/
//课后作业4:某班有5个学生，三门课。分别实现以下要求：
//（1） 求各门课的平均分；
//（2） 找出有两门以上不及格的学生，并输出其学号和不及格课程的成绩；
//（3） 找出三门课平均成绩在85-90分的学生，并输出其学号和姓名
//提示:定义五个学生的结构体,并赋值,然后把其放到数组里面进行操作
//本题答案的值全部固定了,目的是让学生多练习,另外大家可以试着把它放到循环里面
Student stu1;
Student stu2;
Student stu3;
Student stu4;
Student stu5;
//给五个结构体变量赋值
//第一个学生信息
stu1.name = "张三";
stu1.number = 20140101;
stu1.math = 56;
stu1.english = 98;
stu1.music = 78;
//第二个学生信息
stu2.name = "李四";
stu2.number = 20140102;
stu2.math = 95;
stu2.english = 34;
stu2.music = 80;
//第三个学生信息
stu3.name = "王五";
stu3.number = 20140103;
stu3.math = 90;
stu3.english = 55;
stu3.music = 43;
//第四个学生信息
stu4.name = "赵六";
stu4.number = 20140104;
stu4.math = 89;
stu4.english = 67;
stu4.music = 78;
//第五个学生信息
stu5.name = "周八";
stu5.number = 20140105;
stu5.math = 86;
stu5.english = 87;
stu5.music = 85;
//定义一个结构体数组
Student[] s = { stu1, stu2, stu3, stu4, stu5 };
//求各门课的平均值
float aver1 = 0;
float sum1 = 0;
float aver2 = 0;
float sum2 = 0;
float aver3;
float sum3 = 0;
for (int i = 0; i < s.Length; i++)
{
sum1 += s[i].math;
sum2 += s[i].english;
sum3 += s[i].music;
}
aver1 = sum1 / s.Length;
aver2 = sum2 / s.Length;
aver3 = sum3 / s.Length;
Console.WriteLine("数学的平均分数是:{0}" , aver1);
Console.WriteLine("英语的平均分数是:{0}" , aver2);
Console.WriteLine("音乐的平均分数是:{0}" , aver3);
//找出有两门不及格成绩的学生,并把学号和不级格的成绩打印出来
for (int i = 0; i < s.Length; i++)
{
if (s[i].english < 60 && s[i].math < 60 && s[i].music < 60)
{
}
else
{
if (s[i].math < 60 && s[i].english < 60)
{
Console.Write(@"不及格学生的学号为:{0},不及格的成绩为:数学{1},英语{2}" ,
s[i].number, s[i].math, s[i].english);
if (s[i].music < 60)
{
Console.WriteLine(@"不及格学生的学号为:{0},不及格的成绩为:数学{1},英语{2}" ,
s[i].number, s[i].math, s[i].english);
}
}
if (s[i].math < 60 && s[i].music < 60)
{
Console.WriteLine(@"不及格学生的学号为:{0},不及格的成绩为:数学{1},音乐{2}" ,
s[i].number, s[i].math, s[i].music);
}
if (s[i].music < 60 && s[i].english < 60)
{
Console.WriteLine(@"不及格学生的学号为:{0},不及格的成绩为:音乐{1},英语{2}" ,
s[i].number, s[i].music, s[i].english);
}
}
}
//找出三门课平均成绩在85-90分的学生，并输出其学号和姓名
float sumTotal = 0;
float avreTotal = 0;
for (int i = 0; i < s.Length; i++)
{
sumTotal = s[i].math + s[i].english + s[i].music;
avreTotal = sumTotal / 3;
if (avreTotal >= 85 && avreTotal <= 90)
{
Console.WriteLine("三门平均成绩在85-90的学生是:{0},{1}" , s[i].name, s[i].number);
}
}
/*
//课后作业5:用枚举表示网购订单状态，输入推进状态数，模拟订单进展过程，并显示最终状态。
//订单状态参考： 未确认,已确认,已取消,无效,未发货,已发货,未付款,已付款,退货,确认收货,完成。
ShoppingStatus[] s = new ShoppingStatus[11];
Console.WriteLine ("请输入状态值:");
int input = Convert.ToInt32 (Console.ReadLine());
for (int i = 0; i < s.Length; i++) {
s [i] = (ShoppingStatus)i;
}
for (int i = 0; i < input; i++) {
Console.Write ("{0},",s[i]);
}
*/
/*
//课后作业6:创建一个英雄结构体变量，成员包含英雄当前状态。英雄的可以有名字，HP，MP等属性
Hero hero;
hero.name = "李四";
hero.HP = 90;
hero.MP = 100;
*/
/*
//课后作业7:用结构体数组创建两个战队（每队5人），为每个英雄赋随机属性，合算综合战斗力并输出
//提示：战斗力可以是平均等级，攻击力，血量等等。也可以是由这些数值构成的一个综合表达式
HeroAttackValue[] h1 = new HeroAttackValue[5];
HeroAttackValue[] h2 = new HeroAttackValue[5];
Console.WriteLine ("请输入第1队各成员的攻击值:");
int sum1 = 0;
for (int j = 0; j < 5; j++) {
h1 [j].attack = Convert.ToInt32 (Console.ReadLine());
sum1 += h1 [j].attack;
}
Console.WriteLine ("请输入第2队各成员的攻击值:");
int sum2 = 0;
for (int j = 0; j < 5; j++) {
h2 [j].attack = Convert.ToInt32 (Console.ReadLine());
sum2 += h2 [j].attack;
}
Console.WriteLine ("第1队的综合战斗力为{0}:",sum1);
Console.WriteLine ("第2队的综合战斗力为{0}:",sum2);
*/
}
}
}
结构体访问修饰符作者： 574096324@qq.com |
如果在类和结构体里面，成员前面不加任何修饰符，则该成员是private的，
表示在类或者结构体的外部不能点出来的私有成员
如果在名字空间下定义的类或者结果体，默认的访问级别是internal的，
表示只能在改名字空间内部使用外部不能使用；
跨类、名字空间用public
internal在名字空间内使用
二维数组作者： 574096324@qq.com |
//将一个二维数组的行和列交换，存储到另外一个数组中
//int[,] a = new int[2, 3] { { 1, 2 ,3},{ 4, 5, 6 } };
// int[,] b = new int[a.GetLength(1), a.GetLength(0)];
// for (int i = 0; i < b.GetLength(0); i++)
// {
// for (int j = 0; j < b.GetLength(1); j++)
// {
// b[i, j] = a[j, i];
// Console.Write(b[i,j]+" ");
// }
// Console.WriteLine();
//}
//有个3行4列的二维数组，求最大元素以及所在的行和列
//int[,] a = new int[3, 4] { { 1, 2, 3, 4 }, { 5, 6, 7, 8 }, { 9, 10, 11, 12 } };
//int max, row, line;
//max = a[0,0];
//row = 0;
//line = 0;
//for (int i = 0; i < a.GetLength(0); i++)
//{
// for (int j = 0; j < a.GetLength(1); j++)
// {
// if (max < a[i, j])
// {
// max = a[i, j];
// row = i;
// line = j;
// }
// }
//}
//Console.WriteLine("max={0},行号是{1},列号是{2}", max, row+1, line+1);
赋值一个二维数组
//int[,] a = new int[4, 3];
//for (int i = 0; i < a.GetLength(0); i++)
//{
// Console.WriteLine("请输入第{0}行赋值的数",i);
// for (int j = 0; j < a.GetLength(1); j++)
// {
// a[i, j] = int.Parse(Console.ReadLine());
// }
//}
//Console.ReadKey();
////打印数组
//Console.WriteLine("打印赋值的数组");
//for (int i = 0; i < a.GetLength(0); i++)
//{
// for (int j = 0; j < a.GetLength(1); j++)
// {
// Console.Write(a[i, j] + " ");
// }
// Console.WriteLine();
//}
//Console.WriteLine("第一行元素");
//for (int i = 0; i < a.GetLength(1); i++)
//{
// Console.Write(a[0, i] + " ");
//}
//Console.WriteLine("和");
//int sum = 0;
//for (int i = 0; i < a.GetLength(1); i++)
//{
// sum += a[1, i];
//}
//Console.WriteLine("sum=" + sum);
04作业作者： 574096324@qq.com |
1.(**)从控制台先输入你一个整数n,表示之后会输入n个年龄.
将结果按由大到小排序输出.例如:
请输入n:
3
请输入3个年龄:
28
31
19
结果为:
31,28,19
将结果按由大到小排序输出.例如:
请输入n:
3
请输入3个年龄:
28
31
19
结果为:
31,28,19
2.(**)求一个4阶数字矩阵(数值随机产生)对角线的和,如;
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
输出: 69.
3.(***)输入一个n,随机生成一个n*n的二维数组地图,数组元素值随机产生.完成如下操作.例如输入3,
自动生成:
1 2 3
4 5 6
7 8 9
1)求下三角元素的和.(上例为1+4+5+7+8+9=34)
2)遍历二维数组,如果二维数组元素值为偶数,将元素更新为’*’,如果为奇数,将元素更新为’ #’.
# * #
* # *
# * #
3)将上图看做一个游戏地图(#为二维坐标系0,0点),输入一个x,y值,将元素更改为’$’.
例如:输入(0,0),输出
# * #
* # *
$ * #
4.(***)声明一个二维数组,存放游戏玩家可以行走的四个方向(前后左右),假如游戏玩家在二维坐标系的原点,按下w/s/a/d(不区分大小写)代表前后左右,循环输入字符,输出游戏玩家的位置;
5 6 7 8
9 10 11 12
13 14 15 16
输出: 69.
3.(***)输入一个n,随机生成一个n*n的二维数组地图,数组元素值随机产生.完成如下操作.例如输入3,
自动生成:
1 2 3
4 5 6
7 8 9
1)求下三角元素的和.(上例为1+4+5+7+8+9=34)
2)遍历二维数组,如果二维数组元素值为偶数,将元素更新为’*’,如果为奇数,将元素更新为’ #’.
# * #
* # *
# * #
3)将上图看做一个游戏地图(#为二维坐标系0,0点),输入一个x,y值,将元素更改为’$’.
例如:输入(0,0),输出
# * #
* # *
$ * #
4.(***)声明一个二维数组,存放游戏玩家可以行走的四个方向(前后左右),假如游戏玩家在二维坐标系的原点,按下w/s/a/d(不区分大小写)代表前后左右,循环输入字符,输出游戏玩家的位置;
数组作者： 574096324@qq.com |
数组定义，数组初始化：动态初始化，静态初始化
int[ ] array=new int[6]; new 是运算符；数值类型初始值为0，bool类型是false，字符串初始值null.
动态初始化：数据类型[] 数组名=new 数据类型[数组长度]{元素1,元素2};
//数组的动态初始化
int[] array = new int[6] { 1, 2, 3, 4, 5, 6 };
int[] arr1 = new int[] { 1, 2, 3, 4, 5, 6 };
//数组的静态初始化，只能写在一行
//int[] arr2 = { 7, 8, 9, 10, 11, 12 };
//int i = 0;
//Console.WriteLine(arr1[i]);
//i++;
//Console.WriteLine(arr1[i]);
//Console.WriteLine(arr1.Length);
for (int i = 0; i < arr1.Length; i++)
{
Console.WriteLine(arr1[i]);
}
Console.ReadKey();
03循环数组作业作者： 574096324@qq.com |
作业;
1、（*）编程将所有“水仙花数”打印出来，并打印其总个数。 “水仙花数”是一个 各个位立方之和等于该整数的三位数。
2、（**）找出下列整型数组中最大和最小值及其所在位置i。
int[] a={3,5,8,13,47,9};
int[] b ={-23,45,14,65};
3、（***）给定某年某月某日，输出其为这一年的第几天。
4、（**）已知abc+cba = 1333,其中a,b,c均为一位数，编程求出满足条件的a,b,c所有组合。
5、（***）输入两个数，求最大公约数和最小公倍数。（用两种方法：辗转相除法和普通方法）。
6、（****）输入n，分别用*输出边长为n的实心菱形和空心菱形。
例如：n = 3时，输出：
*
***
*****
***
*
*
* *
* *
* *
*
7. 分别用while、do...while、for循环打印1~100之间3的倍数
8. 用while和for循环打印出1-100之间7的倍数，个位为7的数，十位为7的倍数，不是7的倍数并且不包含7
9. 使用嵌套循环产生下列图案：
$
$$
$$$
$$$$
$$$$$
PPT上的练习
1.分别用静态初始化和动态初始化定义一个具有5个元素的整型数组，并求数组元素的和。
2.将上面声明的2个数组对应元素相加，放到另外一个数组中。
3.复制一个数组，即两个数组容量一样，把其中一个数组中的元素复制到另外一个数组中。
循环结构作者： 574096324@qq.com |
//定义一个变量记录圈数，循环变量初始化
int i = 0;
//执行循环的条件即循环条件
while (i < 10)
{
Console.WriteLine("跑" + i);
i++;
//i是循环变量
//条件越来越不满足，最终跳出循环
}
//for(循环变量初始化;条件判断;循环变量变化)
{
//循环体
}Console.WriteLine("{0,2}",i);前面2个空格，-2后面两个空格（左对齐）
//外层行数，内层是行的内容
for (int j = 1; j < 4; j++)
{
for (int i = 1; i < 4; i++)
{
Console .Write("{0,-2}" , i);
}
Console .WriteLine();
}
/九九乘法表
for (int i = 1; i <= 9; i++)
{
for (int j = 1; j <= i; j++)
{
Console .Write("{0}*{1}={2,-3}" , j, i,i*j);
}
Console .WriteLine();
}
Console .ReadKey();
循环总结：
for最常用，通常用于知道循环次数的循环
while也很常用，通常用于不知道循环次数的循环
do……while不是很常用，通常用于需要先执行一次的循环
break跳出本层循环，continue结束本次循环，通常与if连用
for（）中定义的变量只作用于循环体{ }中。
02作业作者： 574096324@qq.com |
1、（*）编写一个程序，要求用户从键盘输入2个float数据,输出最大者.
2、（**）编写一个程序，要求用户从键盘输入3个不同整数,输出中间者.
3、（**）从键盘输入两个实数a和b，代表两点在X轴的坐标,再输入一个0到1之间的数c,代表时间,(假如从a到b需要1s),输出在时间c时的坐标.
例如：输入a为1和b为5，再输入c为0.5,则输出结果为:3.
4、（**）输入一个成绩(0到100之间的整数),如果大于等于90输出:优秀;小于90而大于等于80输出:良好;小于80而大于等于70输出:一般;小于70而大于等于60输出:及格,否则输出:不及格.
5、（***）输入一个生日日期,输出其星座.
6.（*）输入一个整数，判断奇偶，并输出“某某是奇数”或者“某某是偶数”。
7.（*）输入一个数，判断符号。如果大于0，输出“正数”；如果小于0，输出“负数”；如果等于0，输出“0”。
8.（**）有一个函数：x<1的时候，y = x；1<=x<10的时候，y=2x-1；x>=10的时候，y=3x-11。写一段程序，输入x，输出y值
9.（***）输入3个数，判断是否能构成三角形
2、（**）编写一个程序，要求用户从键盘输入3个不同整数,输出中间者.
3、（**）从键盘输入两个实数a和b，代表两点在X轴的坐标,再输入一个0到1之间的数c,代表时间,(假如从a到b需要1s),输出在时间c时的坐标.
例如：输入a为1和b为5，再输入c为0.5,则输出结果为:3.
4、（**）输入一个成绩(0到100之间的整数),如果大于等于90输出:优秀;小于90而大于等于80输出:良好;小于80而大于等于70输出:一般;小于70而大于等于60输出:及格,否则输出:不及格.
5、（***）输入一个生日日期,输出其星座.
6.（*）输入一个整数，判断奇偶，并输出“某某是奇数”或者“某某是偶数”。
7.（*）输入一个数，判断符号。如果大于0，输出“正数”；如果小于0，输出“负数”；如果等于0，输出“0”。
8.（**）有一个函数：x<1的时候，y = x；1<=x<10的时候，y=2x-1；x>=10的时候，y=3x-11。写一段程序，输入x，输出y值
9.（***）输入3个数，判断是否能构成三角形
10. （**）编制一个完成两个数四则运算程序。如：用户输入34+56则输出结果为90.00，要求运算结果保留2位有效小数，用户输入时将2个运算数以及运算符都输入，根据运算符求结果
switch case作者： 574096324@qq.com |
switch (date)
{
case 1:
Console .WriteLine("周一" );
break ;
case 2:
Console .WriteLine("周二" );
break ;
case 3:
Console .WriteLine("周三" );
break ;
case 4:
Console .WriteLine("周四" );
break ;
case 5:
Console .WriteLine("周五" );
break ;
case 6:
Console .WriteLine("周六" );
break ;
case 7:
Console .WriteLine("周日" );
break ;
default :
Console .WriteLine("大保健" );
break ;
}
1.switch里面可以没有default语句块，如果所有的case都不符合要求时
会直接跳出switch开关
2.如果case后面有语句，则一定要有break
3.如果case后面没有任何代码，它会和他后面的case共用一段代码
4.default的位置是随意的
5.case的位置不确定
语句结构作者： 574096324@qq.com |
顺序
分支（if）
程序在运行时发现的错误，称为异常(try catch finally)
try
{
char input = Convert.ToChar(Console.ReadLine());
if (input == 'm')
Console.WriteLine("男性");
else
Console.WriteLine("女性");
}
catch
{
Console.WriteLine("你输入的数据有问题");
}
finally {
}
分支结构作者： 425369880@qq.com |
if语句
if(条件表达式){
语句1;
}esle if{
语句2;
}esle{
语句3;
}
级联式if语句
值为bool类型的表达式
跳出是指跳出if后的一个{}
运算符，逻辑运算作者： 574096324@qq.com |
int a = 3, b = 5;
bool result = (a < b);
Console .WriteLine(result);
//比较两数是否相等用==
bool s = a == b;
Console .WriteLine(s);
//比较两数是否不相等用!=
bool s1 = a != b;
Console .WriteLine(s1);
//逻辑与&&,只有当前后数据都是true的时候，整个逻辑与的值是true
//逻辑与只要其中一个值为false,整个逻辑表达式的值为false
int age = 23;
int age1 = 21;
bool res = (age >= 22) && (age1 >= 20);
Console .WriteLine(res);
//逻辑或||只有||两边的值都是false，整个逻辑或的表达式的值才是false
//如果其中一个值是true，逻辑表达式的结果也是true
res = age >= 22 || ++age1 <= 20; //age1值还是21
Console .WriteLine(res);
//逻辑非!,取反
Console .WriteLine(!res);
//逻辑表达式的短路现象
bool res1 = age <= 22 && ++age1 > 20;
Console .WriteLine("age={0},age1={1}" ,age,age1); //age1值还是21
基本输入、输出函数作者： 574096324@qq.com |
//输入方法，以回车键作为结束标志，得到的是从键盘上输入的字符串
string input = Console .ReadLine();
Console .WriteLine(input);
//得到的是从键盘上输入的第一个字符的ASC码值
int cou = Console .Read();
Console .WriteLine(cou);
换行 Console.WriteLine();
格式化输出,{}为占位符，{}里面的数字对应的是后面变量的序号，变量的序号从0开始依次递增
int n1 = 2, n2 = 3, n3 = 4;
Console.WriteLine("n1={0},n2={1},n3={2}",n1,n2,n3);
float score = 23.5f;
//f表示小数点后保留几位，后面可以加数字
Console .WriteLine("score={0:F2}" ,score);
Console .WriteLine("score={0:000.000}" ,score);
//把数据转换成%形式，并保留两个小数位
Console .WriteLine("{0:p2}" , 1 / 4f);
//如果字符串前面加@，则字符串里面的转义字符失效
Console .Write(@"lanoukeji\n" );
Console .Write("hello world" );
/*数据类型转换
1.隐式转换，用在都是数值类型的两个数据之间;
转换的条件：从取值范围小的往范围大的类型转换，从精确度低往精确度高转，两个条件同时满足
2.强制类型转换
(1)使用类型转换符
(2)把字符串转换成其它格式有两种方法，第一种是Convert，第二种是Parse
*/
int a = 10;
float s = a;
//类型转换符转换
float f = 23.5f;
int b = (int )f;
//把字符串转换成其它格式
string str1 = "123" ;
//Convert方法
//转成int类型
int r1 = Convert .ToInt32(str1);
//转成float类型
float f2 = Convert .ToSingle(str1);
//Parse方法
int r2 = int .Parse(str1);
Console .WriteLine(str1);
char c= (char )99;
Console.WriteLine(c);
课后作业：
1、（*）打印下面图形：
*
* *
* * *
2、（*）编写一个程序，要求用户输入一个美元数量，然后显示出增加%5税率后的相应金额。格式如下所示：
Enter an amount:100.00
With tax added:$105.00
3、（*）从键盘输入两个实数a和b，输出a占b的百分之几。小数点后保留2位。
例如：输入1和4，输出：25.00%
4、（**）编写一个程序，要求用户输入一个美金数量， 然后显示出如何用最少的20美元、10美元、5美元和1美元来付款：
Enter a dollar amout:93
$20 bills: 4
$10 bills: 1
$5 bills:0
$1 bills:3
5、（*）输入两个整数，打印这两个数的和，差，积，余数。
6、（*）查找ASCII码表,输入一个字符，输出其ASCII码。
常量，变量，运算符作者： 574096324@qq.com |
注释，单行，多行，注释函数
定义变量，
交换两个int变量的值（int a,int b)
/int c;c=a;a=b；b=c;
/a=a+b;b=a-b;a=a-b;
变量命名规则：
1.相同变量名不能重复定义
2.只能包含数字，字母，下划线，并且数字不能开头
3.区分大小写，num，Num
4.不能使用关键字
5.见名知义
6.骆驼命名法，如果变量名只有一个单词，则该单词全部小写，如果有两个以上单词，从第二个单词开始每个单词首字母大写
7.@符号只能放在最前面，并且后面不能跟数字
运算符
把常量/变量与运算符组合起来的式子叫表达式
+用在字符串之间，作用是连接两个字符串
++运算符单独放在一行时，与上面一行代码功能相同，都是把变量的值加1，++在前和在后功能也一样
++在前先++，++在后后++
当其不单独在一行时
++在先是先把变量的值加1，之后再把变量参与到运算里面；
++在后是先把变量的值参与到运算里面，运算完了以后在把变量的值加1
复合运算符 a+=b；
