《精通c#(第6版)》【PDF】下载分分快三计划

作者:编程技术

其他设计指南

  • 抛出异常而不是返回某种类型的状态值;
  • 提供完整而有意义的异常信息;
  • 抛出适当的最具体的异常;
  • 不要通过 try - catch 方式隐藏异常;
  • 正确处理异步代码中的异常;
  • 调用事件委托前先判断是否为空;
event EventHandler<string> Notify;
protected virtual void OnNotify(string args)
{
    Notify?.Invoke(this, args);
}
  • 使用受保护的虚方法来触发每个事件;
  • 考虑添加属性变化事件;
  • 当触发事件时要确保 sender != nulll;
  • 如果合适的话,请考虑使用泛型约束;
class SomeClass
{
}

/// <summary>
/// 不推荐
/// </summary>
class MyClass1
{
    void SomeMethod<T>(T t)
    {
        object temp = t;
        SomeClass obj = (SomeClass)temp;
    }
}

/// <summary>
/// 推荐
/// </summary>
class MyClass2
{
    void SomeMethod<T>(T t) where T :SomeClass
    {
        SomeClass obj = t;
    }
}
  • 在返回 LINQ 表达式之前计算它的结果;
  • 如果不是必须,不要使用 thisbase 关键字;

第二部分 C#核心编程结构
第3章
C#核心编程结构
3.1
一个简单的C#程序
3.1.1
Main方法的其他形式
3.1.2
指定应用程序错误代码
3.1.3
处理命令行参数
3.1.4
使用Visual
Studio指定命令行参数
3.2
有趣的题外话:System.Environment类的其他成员
3.3
System.Console类
3.3.1
使用Console类进行基本的输入和输出
3.3.2
格式化控制台输出
3.3.3
格式化数值数据
3.3.4
在控制台应用程序外格式化数值数据
3.4
系统数据类型和相应的C#关键字
3.4.1
变量声明和初始化
3.4.2
内建数据类型与new操作符
3.4.3
数据类型类的层次结构
3.4.4
数值数据类型的成员
3.4.5
System.Boolean的成员
3.4.6
System.Char的成员
3.4.7
从字符串数据中解析数值
3.4.8
System.DateTime和System.TimeSpan
3.4.9
System.Numerics.dll程序集
3.5
使用字符串数据
3.5.1
基本的字符串操作
3.5.2
字符串拼接
3.5.3
转义字符
3.5.4
定义逐字字符串
3.5.5
字符串和相等性
3.5.6
字符串是不可变的
3.5.7
System.Text.StringBuilder类型
3.6
窄化和宽化数据类型转换
3.6.1
checked关键字
3.6.2
设定项目级别的溢出检测
3.6.3
unchecked关键字
3.7
隐式类型本地变量
3.7.1
隐式类型变量的限制
3.7.2
隐式类型数据是强类型数据
3.7.3
隐式类型本地变量的用途
3.8
C#迭代结构
3.8.1
for循环
3.8.2
foreach循环
3.8.3
while和do/while循环结构
3.9
条件结构和关系/相等操作符
3.9.1
if/else语句
3.9.2
关系/相等操作符
3.9.3
逻辑操作符
3.9.4
switch语句
3.10
小结

3.如果方法包含几个不需要同步的重要操作,那么不要同步整个方法

命名指南

  • 不要在变量、参数和类型成员中包含数字;
  • 不要在字段添加前缀;
  • 不要使用缩写;
  • 成员、参数和变量定义要根据它们代表的意义;
  • 使用名词、名词短语或者形容词来定义类型;
  • 使用描述性名称命名泛型参数;
  • 在类成员中不要重复定义和类相同的名称;
  • 成员定义可参考 .Net Framework 的定义方式;
  • 避免使用可能被误解的段名称或字段;
  • 正确定义属性;
  • 在命名方法或局部函数时使用谓词或谓词对象;
  • 使用名称、层、谓词和功能申明命名空间;
  • 使用动词或动词前缀来定义事件;
  • 使用 ingend 后缀来表达事件预处理和发送事件;
  • 使用 on 前缀来定义事件处理程序;
  • 使用 Async 或者 TaskAsync 来标识异步方法;

第2章 构建C#应用程序
2.1
.NET Framework 4.5 SDK的作用
2.2
用csc.exe构建C#应用程序
2.2.1
指定输入输出目标
2.2.2
引用外部程序集
2.2.3
引用多个外部程序集
2.2.4
编译多个源文件
2.2.5
使用C#响应文件
2.3
使用Notepad 构建.NET应用程序
2.4
使用SharpDevelop构建.NET应用程序
2.5
使用Visual C#
Express构建.NET应用程序
2.6
使用Visual
Studio构建.NET应用程序
2.6.1
Visual Studio的独特功能
2.6.2
使用New
Project对话框指向.NET
Framework
2.6.3
解决方案资源管理器
2.6.4
Class View工具
2.6.5
Object Browser工具
2.6.6
集成对代码重构的支持
2.6.7
代码扩展和围绕技术
2.6.8
可视化Class
Designer
2.6.9
集成的.NET Framework 4.5
SDK文档系统
2.7
小结

注释内容:


第11章 高级C#语言特性
11.1
索引器方法
11.1.1
使用字符串值索引对象
11.1.2
重载索引器方法
11.1.3
多维的索引器
11.1.4
在接口类型上定义索引器
11.2
操作符重载
11.2.1
重载二元操作符
11.2.2
=与-=操作符
11.2.3
重载一元操作符
11.2.4
重载相等操作符
11.2.5
重载比较操作符
11.2.6
操作符重载的最后思考
11.3
自定义类型转换
11.3.1
回顾:数值转换
11.3.2
回顾:相关的类类型间的转换
11.3.3
创建自定义转换例程
11.3.4
Square类型的其他显式转换
11.3.5
定义隐式转换例程
11.4
扩展方法
11.4.1
定义扩展方法
11.4.2
在实例层次上调用扩展方法
11.4.3
导入扩展方法
11.4.4
扩展方法的智能感知
11.4.5
扩展实现了指定接口的类型
11.5
匿名类型
11.5.1
定义匿名类型
11.5.2
匿名类型的内部表示方式
11.5.3
方法ToString和GetHashCode的实现
11.5.4
匿名类型的相等语义
11.5.5
包含匿名类型的匿名类型
11.6
指针类型
11.6.1
unsafe关键字
11.6.2
*和 操作符
11.6.3
不安全(与安全)交换功能
11.6.4
通过指针访问字段
11.6.5
stackalloc关键字
11.6.6
使用fixed关键字固定类型
11.6.7
sizeof关键字
11.7
小结

字段命名:

相关链接

  • Code Complete: A Praccal Handbook of Soware Construcon (Steve McConnel)
  • The Art of Agile Development (James Shore)
  • Applying Domain-Driven Design and Paerns: With Examples in C# and .NET (Jimmy Nilsson)
  • Jeremy D. Miller's Blog
  • LINQ Framework Design Guidelines
  • Best Pracces for c# async/await

第一部分 C#与.NET平台
第1章
.NET之道
1.1
初识.NET平台
1.2
.NET平台构造块(CLR、CTS和CLS)简介
1.2.1
基础类库的作用
11.2.3
托管代码与非托管代码
1.3
其他支持.NET的编程语言
1.4
.NET程序集概览
1.4.1
CIL的作用
1.4.2
.NET类型元数据的作用
1.4.3
程序集清单的作用
1.5
CTS
1.5.1
CTS类类型
1.5.2
CTS接口类型
1.5.3
CTS结构类型
1.5.4
CTS枚举类型
1.5.5
CTS委托类型
1.5.6
CTS类型成员
1.5.7
内建的CTS数据类型
1.6
CLS
1.7
CLR
1.8
程序集/命名空间/类型的区别
1.8.1
Microsoft根命名空间的作用
1.8.2
以编程方式访问命名空间
1.8.3
引用外部程序集
1.9
使用ildasm.exe探索程序集
1.9.1
查看CIL代码
1.9.2
查看类型元数据
1.9.3
查看程序集元数据(即清单)
1.10
.NET的平台无关性
1.11
Windows 8应用程序简介
1.11.1
构建Windows
8应用程序
1.11.2
.NET在Windows
8中的作用
1.12
小结

4.仅转化异常来添加信息

框架指南

  • 使用 C# 类型 别名而不是系量进行显式调用;
  • 不要硬编码;统命名空间中的类型;
  • 使用最高警告级别编译代码;
  • 对于简单的表达式避免使用 LINQ
  • 使用 lambda 表达式来代替匿名函数;
  • 只用在使用动态对象时才使用 dynamic 关键字;
  • 支持异步/等待任务延续;

    ...

5.使用equals(),而不是==来检测对象的对等关系

性能指南

  • 使用 Any() 判断 IEnumerable 是否为空 ;
  • 仅对低密集型活动使用异步;
  • 对于 CPU密集型使用 Task.Run
  • 避免同时将 async/awaitTask.Wait 混合使用;
  • 避免 async/await 在单线程环境下出现死锁;

                        《精通c#(第6版)》【PDF】下载链接:

并发:

前不久在 Github 上看见了一位大牛创建一个仓库:CSharpCodingGuidelines,打开之后看了一下 readme.md 相关描述,感觉应该很不错,于是就 clone 到本地拜读一下,这里列一些自己的笔记,方便日后回顾。

第8章接口
8.1
接口类型
8.2
定义自定义接口
8.3
实现接口
8.4
在对象级别调用接口成员
8.4.1
获取接口引用:as关键字
8.4.2
获取接口引用:is关键字
8.5
接口作为参数
8.6
接口作为返回值
8.7
接口类型数组
8.8
使用Visual
Studio实现接口
8.9
显式接口实现
8.10
设计接口层次结构
8.11
构建可枚举类型(IEnumerable和IEnumerator)
8.11.1
用yield关键字构建迭代器方法
8.11.2
构建命名迭代器
8.12
构建可克隆的对象(ICloneable)
8.13
构建可比较的对象(IComparable)
8.13.1
指定多个排序顺序
8.13.2
自定义属性、自定义排序类型
8.14
小结

方法命名:

C# 编程指南

图灵程序设计丛书:精通C#(第6版)是C#领域久负盛名的经典著作,深入全面地讲解了C#编程语言和。NET平台的核心内容,并结合大量示例剖析相关概念。全书分为八部分:C#和。NET平台、C#核心编程结构、C#面向对象编程、高级C#编程结构、用。NET程序集编程、。NET基础类库、WPF和ASP。NETWebForms。第6版是对第5版的进一步更新和完善,内容涵盖了最先进的。NET编程技术和技巧,并准确呈现出C#编程语言的最新变化和。NET4。5Framework的新特性。

类型安全:

  • 基本原则
  • 类设计指南
  • 属性成员设计指南
  • 其他设计指南
  • 可维护性指南
  • 命名指南
  • 性能指南
  • 框架指南
  • 文档指南
  • 布局指南
  • 相关链接

第4章 C#核心编程结构
4.1
方法和参数修饰符
4.1.1
默认的参数传递行为
4.1.2
out修饰符
4.1.3
ref修饰符
4.1.4
params修饰符
4.1.5
定义可选参数
4.1.6
使用命名参数调用方法
4.1.7
成员重载
4.2
C#数组
4.2.1
C#数组初始化语法
4.2.2
隐式类型本地数组
4.2.3
定义object数组
4.2.4
使用多维数组
4.2.5
数组作为参数(和返回值)
4.2.6
System.Array基类
4.3
枚举类型
4.3.1
控制枚举的底层存储
4.3.2
声明枚举变量
4.3.3
System.Enum类型
4.3.4
动态获取枚举的名称/值对
4.4
结构类型
4.5
值类型和引用类型
4.5.1
值类型、引用类型和赋值操作符
4.5.2
包含引用类型的值类型
4.5.3
按值传递引用类型
4.5.4
按引用传递引用类型
4.5.5
值类型和引用类型:最后的细节
4.6
C#可空类型
4.6.1
使用可空类型
4.6.2
??操作符
4.7
小结

4.尽量保留元音字母

布局指南

  • 使用常规布局;
  • 根据公式要求进行命名空间的约束;
  • 将成员置于定义良好的顺序中;
  • 谨慎使用 #region
  • 适当使用表现健全的成员;

《图灵程序设计丛书:精通C#(第6版)》由微软C#MVPAndrewTroelsen编写,第6版专门针对C#5。0和。NET4。5进行了细致入微的修订,是各层次。NET开发人员的必读之作。

编程约定:

文档指南

  • 使用美式英语来编写相关文档;
  • 文档中的代码部分要保证完整性;
  • 与其他开发人员一起编写 xml 文档;
  • 编写 MSDN 风格的技术文档;
  • 避免内联注释;
  • 注释值应该用来解释复杂的算法或讨论;
  • 不要使用注释来跟踪要在以后完成的工作;

第6章继承和多态
6.1
继承的基本机制
6.1.1
指定既有类的父类
6.1.2
多个基类
6.1.3
sealed关键字
6.2
回顾Visual
Studio类关系图
6.3
OOP的第二个支柱:继承
6.3.1
使用base关键字控制基类的创建
6.3.2
家族的秘密:protected关键字
6.3.3
增加密封类
6.4
包含/委托编程
6.5
OOP的第三个支柱:C#的多态支持
6.5.1
virtual和override关键字
6.5.2
使用Visual Studio
IDE重写虚方法
6.5.3
密封虚成员
6.5.4
抽象类
6.5.5
构建多态接口
6.5.6
成员投影
6.6
基类/派生类的转换规则
6.6.1
C#的as关键字
6.6.2
C#的is关键字
6.7
超级父类:System.Object
6.7.1
重写System.Object.ToString
6.7.2
重写System.Object.Equals
6.7.3
重写System.Object.GetHashCode
6.7.4
测试修改后的Person类
6.7.5
System.Object的静态成员
6.8
小结

2.使用人们熟悉的名称

属性成员设计指南

  • 允许按任意顺序设置属性;
  • 使用方法而不是属性;
  • 不要使用相互排斥的属性;
  • 属性、方法或者本地方法只应该做一件事情;
  • 不要通过静态成员公开有状态的对象;
  • 用 IEnumerable 或者 ICollection 来代替具体的集合对象作为返回值;
  • 如果属性、参数和返回值是字符串或者集合类型的话,则永远不应该为空;
  • 尽可能地定义具体的参数;
  • 考虑使用特定域的值类型而不是基元;

更多书单和推荐电子书请关注:

2.用同步的包装器,提供同步接口

基本原则

  • Astonishment 原则:你的代码应该尽量做到让每一个人都能理解。任何人都有写出让机器认识的代码,但是并不是每个人都能写出让人认识的代码;
  • Kiss 原则:类似 Python 之禅 里面说的那样,简单胜于复杂;
  • YAGNI 原则:代码尽量能做到可扩展,但请不要过度重构,因为你不能预知未来;
  • DRY 原则:不要重复造轮子,除非你有时间或者你造的轮子会比别人的优秀;
  • 面向对象编程原则:继承、封装、多态、抽象;

第7章结构化异常处理
7.1
错误、bug与异常
7.2
.NET异常处理的作用
7.2.1
.NET异常处理的四要素
7.2.2
System.Exception基类
7.3
最简单的例子
7.3.1
引发普通的异常
7.3.2
捕获异常
7.4
配置异常的状态
7.4.1
TargetSite属性
7.4.2
StackTrace属性
7.4.3
HelpLink属性
7.4.4
Data属性
7.5
系统级异常
7.6
应用程序级异常
7.6.1
构建自定义异常,第一部分
7.6.2
构建自定义异常,第二部分
7.6.3
构建自定义异常,第三部分
7.7
处理多个异常
7.7.1
通用的catch语句
7.7.2
再次引发异常
7.7.3
内部异常
7.7.4
finally块
7.8
谁在引发什么异常
7.9
未处理异常的后果
7.10
使用Visual
Studio调试未处理的异常
7.11
小结

1.以java.lang.Object包装通用类,提供静态类型检查

目录

第12章 LINQ to Object
12.1
LINQ特有的编程结构
12.1.1
隐式类型本地变量
12.1.2
对象和集合初始化语法
12.1.3
Lambda表达式
12.1.4
扩展方法
12.1.5
匿名类型
12.2
LINQ的作用
12.2.1
LINQ表达式是强类型的
12.2.2
核心LINQ程序集
12.3
将LINQ查询应用于原始数组
12.3.1
再一次,不使用LINQ
12.3.2
反射LINQ结果集
12.3.3
LINQ和隐式类型本地变量
12.3.4
LINQ和扩展方法
12.3.5
延迟执行的作用
12.3.6
立即执行的作用
12.4
返回LINQ查询的结果
12.5
将LINQ查询应用到集合对象
12.5.1
访问包含的子对象
12.5.2
将LINQ查询应用于非泛型集合
12.5.3
使用OfType筛选数据
12.6
C# LINQ查询操作符
12.6.1
基本的选择语法
12.6.2
获取数据子集
12.6.3
投影新数据类型
12.6.4
使用Enumerable获取总数
12.6.5
反转结果集
12.6.6
对表达式进行排序
12.6.7
维恩图工具
12.6.8
移除重复
12.6.9
LINQ聚合操作
12.7
LINQ查询语句的内部表示
12.7.1
用查询操作符建立查询表达式(复习)
12.7.2
使用Enumerable类型和Lambda表达式来建立查询表达式
12.7.3
使用Enumerable类型和匿名方法来建立查询表达式
12.7.4
用Enumerable类型和原始委托建立查询表达式
12.8
小结

变量命名:

可维护性指南

  • 方法内部的代码段尽量不要超过 7 行;
  • 确保所有成员私有,类的类型默认为为 internal sealed
  • 避免双重条件;
  • 在其包含的命名空间内命名程序集;
  • 将源文件命名为它所包含的类型;
  • 将源文件的内容限制为一种类型;
  • 将不同的逻辑函数放到同一个部分类中;
  • 在使用一个类型时,使用 using 关键字导入需要的命名空间,而不是类型的完整空间标识;
  • 不要使用魔法数;
  • 只有当类型显而易见时才使用 var 关键字;
  • 定义变量时尽可能地初始化;
  • 在相互独立的代码段中定义临时变量;
  • 若对象有集合需要初始化的话在进行对象初始化的同时进行集合初始化;
  • 不要显式进行 bool 值的比较;
  • 避免嵌套循环;
  • 在使用 ifelsedowhileforforeachcase 的同时使用 {}
  • switch case 代码段中添加 default 逻辑;
  • 在所有的 ifelse if 后再添加 else;
  • 避免使用多个返回值;
  • 考虑使用简单的条件语句代替 if else
  • 封装属性、方法或局部函数中的复杂表达式;
  • 再合适的情况下尝试重载方法;
  • 使用可选参数来代替重载;
  • 避免使用命名参数;
  • 避免定义超过3个参数的签名;
  • 避免函数签名为布尔类型;
  • 不要将参数作为临时变量使用;
  • 将模式作为操作;
  • 不要注释代码;

第13章对象的生命周期
13.1
类、对象和引用
13.2
对象生命周期的基础
13.2.1
CIL的new指令
13.2.2
将对象引用设置为空
13.3
应用程序根的作用
13.4
对象的代
13.5
.NET 1.0至.NET
3.5的并发垃圾回收
13.6
.NET 4.0及后续版本
13.7
System.GC类型
13.8
构建可终结对象
13.8.1
重写System.Object.Finalize
13.8.2
终结过程的细节
13.9
构建可处置对象
13.10
构建可终结类型和可处置类型
13.11
延迟对象实例化
13.12
小结

3.为每个包编写总结和概述

类设计指南

  • 一个类/接口应该只有一个用途,要符 合单一职责 原则;
  • 只创建返回有用对象的构造函数,当构造函数的参数超过 3 的话,你就应该考虑你的类设计是否过于臃肿;
  • 接口应该短小精悍,其定义要明确清晰地传达出其具有的行为;
  • 如果一种行为有多种实现,请考虑使用接口而不是基类;
  • 尽量使用接口将类进行彼此解耦;
  • 避免使用静态类;
  • 不要使用 new 关键字来禁止编译器显示相关警告;
public class Book
{
    public virtual void Print()
    {
        Console.WriteLine("Printing Book");
    }
}

public class PocketBook : Book
{
    public new void Print()
    {
        Console.WriteLine("Printing PocketBook");
    }
}

class Program
{
    static void Main(string[] args)
    {
        PocketBook pocketBook = new PocketBook();
        pocketBook.Print();

        ((Book)pocketBook).Print();

        Console.ReadKey();
    }
}

在上述代码段中,我们创建一个基类 book,并定义了一个 Print() 方法,接着我们创建一个子类 PocketBook,并通过 new 关键字来重写基类方法。在项目复杂的情况下,使用这种方式将导致我们不能准确预测是子类调用还是父类调用,使代码复杂度提升。

  • 应该可以将派生类当作基类对象来处理;
  • 不要引用基类的派生类;
  • 避免暴露一个对象依赖的其它对象;
  • 避免双向依赖;
  • 类应该有状态和行为;
  • 类应该保护其内部状态的一致性;

    图灵程序设计丛书:精通C#
目录:

命名约定:

第三部分 C#面向对象编程
第5章封装
5.1
C#类类型
5.2
构造函数
5.2.1
默认构造函数的作用
5.2.2
定义自定义的构造函数
5.2.3
再谈默认构造函数
5.3
this关键字的作用
5.3.1
使用this进行串联构造函数调用
5.3.2
观察构造函数流程
5.3.3
再谈可选参数
5.4
static关键字
5.4.1
定义静态数据
5.4.2
《精通c#(第6版)》【PDF】下载分分快三计划。定义静态方法
5.4.3
定义静态构造函数
5.4.4
定义静态类
5.5
定义OOP的支柱
5.5.1
封装的作用
5.5.2
继承的作用
5.5.3
多态的作用
5.6
C#访问修饰符
5.6.1
默认的访问修饰符
5.6.2
访问修饰符和嵌套类型
5.7
第一个支柱:C#的封装服务
5.7.1
使用传统的访问方法和修改方法执行封装
5.7.2
使用.NET属性进行封装
5.7.3
使用类的属性
5.7.4
只读和只写属性
5.7.5
静态属性
5.8
自动属性
5.8.1
与自动属性交互
5.8.2
关于自动属性和默认值
5.9
对象初始化语法
5.9.1
使用初始化语法调用自定义构造函数
5.9.2
初始化内部类型
5.10
《精通c#(第6版)》【PDF】下载分分快三计划。常量数据
5.10.1
只读字段
5.10.2
静态只读字段
5.11
分部类型
5.12
小结

1.常量的每个单词均大写,单词之间使用下划线连接

第四部分 高级C#编程结构
第9章集合与泛型
9.1
集合类的动机
9.1.1
System.Collections命名空间
9.1.2
System.Collections.Specialized命名空间
9.2
非泛型集合的问题
9.2.1
性能问题
9.2.2
类型安全问题
9.2.3
初识泛型集合
9.3
泛型类型参数的作用
9.3.1
为泛型类/结构指定类型参数
9.3.2
为泛型成员指定类型参数
9.3.3
为泛型接口指定类型参数
9.4
System.Collections.Generic命名空间
9.4.1
集合初始化语法
9.4.2
使用List类
9.4.3
使用Stack类
9.4.4
使用Queue类
9.4.5
使用SortedSet类
9.5
System.Collections.ObjectModel命名空间
9.6
创建自定义泛型方法
9.7
创建自定义泛型结构和类
9.8
类型参数的约束
9.8.1
使用where关键字的示例
9.8.2
操作符约束的不足
9.9
小结

好处不多说了,但是有几个原则如下:

第10章委托、事件和Lambda表达式
10.1
.NET委托类型
10.1.1
在C#中定义委托类型
10.1.2
System.MulticastDelegate与System.Delegate基类
10.2
最简单的委托示例
10.3
使用委托发送对象状态通知
10.3.1
支持多路广播
10.3.2
从委托的调用列表中移除成员
10.3.3
方法组转换语法
10.4
泛型委托
10.5
C#事件
10.5.1
event关键字
10.5.2
揭开事件的神秘面纱
10.5.3
监听传入的事件
10.5.4
使用Visual
Studio简化事件注册
10.5.5
创建自定义的事件参数
10.5.6
泛型EventHandler委托
10.6
C#匿名方法
10.7
Lambda表达式
10.7.1
剖析Lambda表达式
10.7.2
使用多个语句处理参数
10.7.3
含有多个(或零个)参数的Lambda表达式
10.7.4
使用Lambda表达式重新编写CarEvents示例
10.8
小结

2.用标准注释格式隐藏代码而不必删除它们

7.如果两个case标记之间没有break语句,就在中间加入“fall-through”注释

1.类和接口名中的每个单词的第一个字母大写

2.完整描述每个方法的签名

1.使用不受检查、运行时的异常来报告可能在程序逻辑中出错的严重未查明错误

1.用等价的方法替换重复的、复杂的表达式

4.用断言检测方法的前置条件和后置条件

3.定义小的类和小的方法

1.为使用和维护你的代码的人编写文档

1.仅添加有助于理解你的代码的内部注释

1.缩进嵌套的代码:在每个代码块和嵌套中加入缩进,缩进代码,加强可读性。这些地方包括【类定义,内部类定义,方法定义,静态块,for循环语句,if-else语句,try、catch和finally块,匿名内部类,while语句,do-while语句】

来自《The Elements of Java Style》-《Java编程风格》一书,值得一读的书籍,会让你在细节上节省很多时间,合作之间更加愉快!

6.用finally语句块释放资源

同步:

4.把优化工作留在日后

2.为公用,受保护,包,私有成员建立文档

注释类型:

4.为不重要的临时变量简历并使用一套标准名字

2.注释和代码要同步

注释风格:

1.避免同步

异常处理:

4.在标识符第一次出现的时候用{@link}标签

3.用返回代码报告可预知的状态改变

3.谨慎使用过长的名字,可以使用简明通用的缩写

5.使用notify()而不是notifyAll()

6.不要使用大小写来区分的名字

打包约定:

2.以类的形式封装枚举类型

2.使用单独的小写词作为每个包的根名

文档约定:

3.使用空白:关键字和左括号之间,右括号和紧随其后的关键字,除了”.”之外的运算符与其前后的表达式之间用空格隔开。每个逻辑上独立的方法和代码段之间,定义类或者接口的成员之间,每个类和接口之间应该加入空白行。

2.使用检查异常来报告可能发生,而在正常的程序运行时极少发生的错误

3.避免使用行尾注释

3.集合引用名要用复数形式

包命名:

8.将高层设计和架构作为稳定的抽象,组织为稳定的包

5.建立并使用一套关键词来标识尚未解决的问题

3.遵循JavaBean中命名属性访问函数方法:set,get,is

1.每个类、接口、字段和方法都编写概述

4.读写实例变量的时候避免不必要的同步

2.使用块语句代替控制流结构的表达式

格式规范:

2.坚持最小惊奇原则

2.不要从构造函数中调用非final方法

2.断开很长的句子:第一,如果包含了逗号,那么在每一个逗号后面都另起一行,把逗号后面的每一个表达式都和逗号前面的表达式的第一个字母对齐。第二,应该在优先级最低的运算符之前断行。

语句和表达式:

类型命名:

1.用你所在组织的域名的倒序小写形式作为包的根限定词

2.用名词命名变量

1.保持原有风格

1.在编写代码前描述编程接口

8.标记空语句

3.用断言捕捉代码中的逻辑错误

3.包含示例

9.省略事物概述中的对象和动词

3.使用括号明确操作顺序

1.用名词命名类

3.使用积极的语气,省略无用的词语

3.将代码放入<pre>…</pre>标签中

1.用文档注释来描述编程接口

4.定义子类,以便任何使用超类的地方都可以使用子类

参数命名:

4.为包的每个应用程序或组编写概述

3.仅当新旧版本二进制兼容的时候,其包可以使用相同的名字,否则,请使用新名字

6.为同步初始化使用双重检查模式

4.为前置、后置、不变条件编写文档

5.使所有字段私有

常量命名:

1.变量命中的第一个单词小写,其后的每个单词的第一个字母大写

6.使用多态来替代instanceof

内部注释:

1.仅在适当的地方使用线程

6.易于修改的包不要依赖于难以修改的包

1.对所有文档注释使用统一的格式和组织结构

2.关键字,标识符和常量应放到<code>…</code>标签中

3.重新初始化并重新使用对象,尽量不要新建对象

文档注释:

5.将不稳定的类和接口隔离在单独的包中

4.用行尾注释解释局部变量声明

4.不要直接使用Tab控制符:不同环境对Tab控制符的解释也是不同的。

2.具有成组相关属性,静态服务或者常量的类名字使用复数形式

3.用嵌套的构造函数消除冗余代码

3.第一次就做对

2.通过本地类型和其他具体类型建立具体类型

断言:

5.不要私自处置运行时或者错误异常

3.用单行注释解释实现细节

2.避免创建不必要的对象

7.最大化抽象最大化稳定性

1.构造状态有效的对象

10.使用this而不是the来指代当前类中的实例

1.方法名中的第一个单词小写,其后每个单词的第一个字母大写

4.记录所有非规范行为

类命名:

1.名称应该具有实际意义

3.重用/发布等价原则

1.用名词或者形容词命名接口

6.使用第三人称叙述的形式

2.用动词命名方法

5.缩写词的第一个字母大写

1.按照约定编程

1.将表示基础数据类型的类声明为final类型

6.为同步语法编写文档

4.在switch语句中的最后一个case体使用break语句

2.描写代码为什么这样做,而不是在做什么

为了让学习变得轻松、高效,今天给大家免费分享一套Java教学资源。帮助大家在成为Java架构师的道路上披荆斩棘。需要资料的欢迎加入学习交流群:9285,05736

11.方法名或者构造函数名不需圆括号,除非你想突出一个特殊的签名

6.在嵌套程度高的控制结构中标记出嵌套结束位置

构造:

5.为Javadoc标签简历并使用一套固定的顺序

接口命名:

1.使用懒惰初始化

5.为已知的缺陷和不足编写文档

1.使用this字段变量可以区分开局部变量

效率:

2.共同封闭原则

4.无环依赖原则

7.编写独立的概述

1.构造函数或者”set”方法给字段分配参数赋值,参数名应该和字段名相同

3.尽量使用泛型

1.将经常使用、更改、同时发布或者互相依存的类型,放在同一个包里

8.省略概述中动作和服务的主语

2.用无用代码消除机制实现断言

本文由分分快三计划发布,转载请注明来源

关键词: 分分快三计划 程序员