多个线程访问同一个类里面的静态成员变量

如下所示,product1, product2,product3是三个不同的线程,但由于Producer类里面的成员变量count是静态变量,

所以实际上count是三个线程的共享成员变量,对其进行操作时,最好加上锁访问机制。

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;

public class BlockingQueueTest {

	public static void main(String[] args) throws InterruptedException {
		// 声明一个容量为10的缓存队列
		BlockingQueue<String> queue = new LinkedBlockingQueue<String>(10);

		Producer producer1 = new Producer(queue, 1);
		Producer producer2 = new Producer(queue, 2);
		Producer producer3 = new Producer(queue, 3);
		Consumer consumer = new Consumer(queue);

		// 借助Executors
		ExecutorService service = Executors.newCachedThreadPool();
		// 启动线程
		service.execute(producer1);
		service.execute(producer2);
		service.execute(producer3);
		// service.execute(consumer);
  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
在一小时内学会 C#。使用例程,简单却完整的探索 C# 语言的构造和特点。本文特别适合有 C++ 基础却没有太多精力学习 C# 的读者。 关于作者 Aisha Ikram 我现在在英国一家软件公司任技术带头人。我是计算机科学的硕士。我主要使用 .NET 1.1/2.0, C#, VB.NET, ASP.NET, VC++ 6, MFC, ATL, COM/DCOM, SQL Server 2000/2005等。最近我在学习 .NET 3.x 的全部内容。我的免费源代码和文章网站是 http://aishai.netfirms.com 职业:团队带头人 位置:英国 简介 C# 是一种具有 C++ 特性,Java 样式及 BASIC 快速建模特性的编程语言。如果你已经知晓 C++ 语言,本文将在不到一小时的时间内带你快速浏览 C# 的语法。如果熟悉 Java 语言,Java 的编程结构、打包和垃圾回收的概念肯定对你快速学习 C# 大有帮助。所以我在讨论 C# 语言构造的时候会假设你知道 C++。 本文通过一系列例程以简短但全面的方式讨论了 C# 语言构造和特性,所以你仅需略览代码片刻,即可了解其概念。 注意:本文不是为 C# 宗师而写。有很多初学者的 C# 文章,这只是其中之一。 接下来关于 C# 的讨论主题: ? 编程结构 ? 命名空间 ? 数据型 ? 变量 ? 运算符与表达式 ? 枚举 ? 语句 ? 与结构 ? 修饰符 ? 属性 ? 接口 ? 函数参数 ? 数组 ? 索引器 ? 装箱与拆箱 ? 委托 ? 继承与多态 以下主题不会进行讨论: ? C++ 与 C# 的共同点 ? 诸如垃圾回收、线程、文件处理等概念 ? 数据型转换 ? 异常处理 ? .NET 库 编程结构 和 C++ 一样,C# 是大小写敏感的。半角分号(;)是语句分隔符。和 C++ 有所区别的是,C# 中没有单独的声明(头)和实现(CPP)文件。所有代码(声明和实现)都放在扩展名为 cs 的单一文件中。 看看 C# 中的 Hello World 程序。 复制内容到剪贴板 代码: using System; namespace MyNameSpace { class HelloWorld { static void Main(string[] args) { Console.WriteLine ("Hello World"); } } } C# 中所有内容都打包在中,而所有的又打包在命名空间中(正如文件存与文件夹中)。和 C++ 一样,有一个主函数作为你程序的入口点。C++ 的主函数名为 main,而 C# 中是大写 M 打头的 Main。 块或结构定义之后没有必要再加一个半角分号。C++ 中是这样,但 C# 不要求。 命名空间 每个都打包于一个命名空间。命名空间的概念和 C++ 完全一样,但我们在 C# 中比在 C++ 中更加频繁的使用命名空间。你可以用点(.)定界符访问命名空间中的。上面的 Hello World 程序中,MyNameSpace 是其命名空间。 现在思考当你要从其他命名空间的访问 HelloWorld 。 复制内容到剪贴板 代码: using System; namespace AnotherNameSpace { class AnotherClass { public void Func() { Console.WriteLine ("Hello World"); } } } 现在在你的 HelloWorld 中你可以这样访问: 复制内容到剪贴板 代码: using System; using AnotherNameSpace; // 你可以增加这条语句 namespace MyNameSpace { class HelloWorld { static void Main(string[] args) { AnotherClass obj = new AnotherClass(); obj.Func(); } } } 在 .NET 库中,System 是包含其他命名空间的顶层命名空间。默认情况下存在一个全局命名空间,所以在命名空间外定义的直接进到此全局命名空间中,因而你可以不用定界符访问。 你同样可以定义嵌套命名空间。 Using #include 指示符被后跟命名空间名的 using 关键字代替了。正如上面的 using System。System 是最基层的命名空间,所有其他命名空间和都包含于其中。System 命名空间中所有对象的基是 Object。 变量 除了以下差异,C# 中的变量几乎和 C++ 中一样: 1. C# 中(不同于 C++)的变量,总是需要你在访问它们前先进行初始化,否则你将遇到编译时错误。故而,不可能访问未初始化的变量。 2. 你不能在 C# 中访问一个“挂起”指针。 3. 超出数组边界的表达式索引值同样不可访问。 4. C# 中没有全局变量或全局函数,取而代之的是通过静态函数和静态变量完成的。 数据型 所有 C# 的型都是从 object 继承的。有两种数据型: 1. 基本/内建型 2. 用户定义型 以下是 C# 内建型的列表: 型 字节 描述 byte 1 unsigned byte sbyte 1 signed byte short 2 signed short ushort 2 unsigned short int 4 signed integer uint 4 unsigned integer long 8 signed long ulong 8 unsigned long float 4 floating point number double 8 double precision number decimal 8 fixed precision number string - Unicode string char - Unicode char bool true, false boolean 注意:C# 的型范围和 C++ 不同。例如:long 在 C++ 中是 4 字节而在 C# 中是 8 字节。bool 和 string 型均和 C++ 不同。bool 仅接受真、假而非任意整数。 用户定义型文件包含: 1. (class) 2. 结构(struct) 3. 接口(interface) 以下型继承时均分配内存: 1. 值型 2. 参考型 值型 值型是在堆栈中分配的数据型。它们包括了: ? 除字符串,所有基本和内建型 ? 结构 ? 枚举型 引用型 引用型在堆(heap)中分配内存且当其不再使用时,将自动进行垃圾清理。和 C++ 要求用户显示创建 delete 运算符不一样,它们使用新运算符创建,且没有 delete 运算符。在 C# 中它们自动由垃圾回收系统回收。 引用型包括: ? ? 接口 ? 集合型如数组 ? 字符串 枚举 C# 中的枚举和 C++ 完全一样。通过关键字 enum 定义。 例子: 复制内容到剪贴板 代码: enum Weekdays { Saturday, Sunday, Monday, Tuesday, Wednesday, Thursday, Friday } 与结构 除了内存分配的不同外,和结构就和 C++ 中的情况一样。的对象在堆中分配,并使用 new 关键字创建。而结构是在栈(stack)中进行分配。C# 中的结构属于轻量级快速数据型。当需要大型数据型时,你应该创建。 例子: 复制内容到剪贴板 代码: struct Date { int day; int month; int year; } class Date { int day; int month; int year; string weekday; string monthName; public int GetDay() { return day; } public int GetMonth() { return month; } public int GetYear() { return year; } public void SetDay(int Day) { day = Day ; } public void SetMonth(int Month) { month = Month; } public void SetYear(int Year) { year = Year; } public bool IsLeapYear() { return (year/4 == 0); } public void SetDate (int day, int month, int year) { } ... } 属性 如果你熟悉 C++ 面向对象的方法,你一定对属性有自己的认识。对 C++ 来说,前面例子中 Date 的属性就是 day、month 和 year,而你添加了 Get 和 Set 方法。C# 提供了一种更加便捷、简单而又直接的属性访问方式。 所以上面的应该写成这样: 复制内容到剪贴板 代码: using System; class Date { public int Day{ get { return day; } set { day = value; } } int day; public int Month{ get { return month; } set { month = value; } } int month; public int Year{ get { return year; } set { year = value; } } int year; public bool IsLeapYear(int year) { return year%4== 0 ? true: false; } public void SetDate (int day, int month, int year) { this.day = day; this.month = month; this.year = year; } } 这里是你 get 和 set 属性的方法: 复制内容到剪贴板 代码: class User { public static void Main() { Date date = new Date(); date.Day = 27; date.Month = 6; date.Year = 2003; Console.WriteLine ("Date: {0}/{1}/{2}", date.Day, date.Month, date.Year); } } 修饰符 你必须知道 C++ 中常用的 public、private 和 protected 修饰符。我将在这里讨论一些 C# 引入的新的修饰符。 readonly readonly 修饰符仅用于修饰的数据成员。正如其名字说的,一旦它们已经进行了写操作、直接初始化或在构造函数中对其进行了赋值,readonly 数据成员就只能对其进行读取。readonly 和 const 数据成员不同之处在于 const 要求你在声明时进行直接初始化。看下面的例程: 复制内容到剪贴板 代码: class MyClass { const int constInt = 100; //直接进行 readonly int myInt = 5; //直接进行 readonly int myInt2; public MyClass() { myInt2 = 8; //间接进行 } public Func() { myInt = 7; //非法 Console.WriteLine(myInt2.ToString()); } } sealed 带有 sealed 修饰符的不允许你从它继承任何。所以如果你不想一个被继承,你可以对该使用 sealed 关键字。 复制内容到剪贴板 代码: sealed class CanNotbeTheParent { int a = 5; } unsafe 你可以使用 unsafe 修饰符在 C# 中定义一个不安全上下文。在不安全上下文中,你可以插入不安全代码,如 C++ 的指针等。参见以下代码: 复制内容到剪贴板 代码: public unsafe MyFunction( int * pInt, double* pDouble) { int* pAnotherInt = new int; *pAnotherInt = 10; pInt = pAnotherInt; ... *pDouble = 8.9; } 接口 如果你有 COM 的思想,你马上就知道我在说什么了。接口是只包含函数签名而在子中实现的抽象基。在 C# 中,你可以用 interface 关键字声明这样的接口。.NET 就是基于这样的接口的。C# 中你不能对进行多重继承——这在 C++ 中是允许的。通过接口,多重继承的精髓得以实现。即你的子可以实现多重接口。(译注:由此可以实现多重继承) 复制内容到剪贴板 代码: using System; interface myDrawing { int originx { get; set; } int originy { get; set; } void Draw(object shape); } class Shape: myDrawing { int OriX; int OriY; public int originx { get{ return OriX; } set{ OriX = value; } } public int originy { get{ return OriY; } set{ OriY = value; } } public void Draw(object shape) { ... // 做要做的事 } // 自身的方法 public void MoveShape(int newX, int newY) { ..... } } 数组 数组在 C# 中比 C++ 中要高级很多。数组分配于堆中,所以是引用型的。你不能访问数组边界外的元素。所以 C# 防止你引发那种 bug。同时也提供了迭代数组元素的帮助函数。foreach 是这样的迭代语句之一。C++ 和 C# 数组的语法差异在于: 方括号在型后面而不是在变量名后面 创建元素使用 new 运算符 C# 支持一维、多维和交错数组(数组的数组) 例子: 复制内容到剪贴板 代码: int[] array = new int[10]; // int 型一维数组 for (int i = 0; i < array.Length; i++) array = i; int[,] array2 = new int[5,10]; // int 型二维数组 array2[1,2] = 5; int[,,] array3 = new int[5,10,5]; // int 型三维数组 array3[0,2,4] = 9; int[][] arrayOfarray = new int[2]; // int 型交错数组 - 数组的数组 arrayOfarray[0] = new int[4]; arrayOfarray[0] = new int[] {1,2,15}; 索引器 索引器用于书写一个可以通过使用 [] 像数组一样直接访问集合元素的方法。你所需要的只是指定待访问实例或元素的索引。索引器的语法和属性语法相同,除了接受作为元素索引的输入参数外。 例子: 注意:CollectionBase 是用于建立集合的库。List 是 CollectionBase 中用于存放集合列表的受保护成员。 复制内容到剪贴板 代码: class Shapes: CollectionBase { public void add(Shape shp) { List.Add(shp); } //indexer public Shape this[int index] { get { return (Shape) List[index]; } set { List[index] = value ; } } } 装箱/拆箱 装箱的思想在 C# 中是创新的。正如前面提到的,所有的数据型,无论是内建的还是用户定义的,都是从 System 命名空间的基 object 继承的。所以基础的或是原始的型打包为一个对象称为装箱,相反的处理称为拆箱。 例子: 复制内容到剪贴板 代码: class Test { static void Main() { int myInt = 12; object obj = myInt ; // 装箱 int myInt2 = (int) obj; // 拆箱 } } 例程展示了装箱和拆箱两个过程。一个 int 值可以被转换为对象,并且能够再次转换回 int。当某种值型的变量需要被转换为一个引用型时,便会产生一个对象箱保存该值。拆箱则完全相反。当某个对象箱被转换回其原值型时,该值从箱中拷贝至适当的存储空间。 函数参数 C# 中的参数有三种型: 1. 按值传递/输入参数 2. 按引用传递/输入-输出参数 3. 输出参数 如果你有 COM 接口的思想,而且还是参数型的,你会很容易理解 C# 的参数型。 按值传递/输入参数 值参数的概念和 C++ 中一样。传递的值复制到了新的地方并传递给函数。 例子: 复制内容到剪贴板 代码: SetDay(5); ... void SetDay(int day) { .... } 按引用传递/输入-输出参数 C++ 中的引用参数是通过指针或引用运算符 & 传递的。C# 中的引用参数更不易出错。你可以传递一个引用地址,你传递一个输入的值并通过函数得到一个输出的值。因此引用参数也被称为输入-输出参数。 你不能将未初始化的引用参数传递给函数。C# 使用关键字 ref 指定引用参数。你同时还必须在传递参数给要求引用参数的函数时使用关键字 ref。 例子: 复制内容到剪贴板 代码: int a= 5; FunctionA(ref a); // 使用 ref,否则将引发编译时错误 Console.WriteLine(a); // 打印 20 复制内容到剪贴板 代码: void FunctionA(ref int Val) { int x= Val; Val = x* 4; } 输出参数 输出参数是只从函数返回值的参数。输入值不要求。C# 使用关键字 out 表示输出参数。 例子: 复制内容到剪贴板 代码: int Val; GetNodeValue(Val); 复制内容到剪贴板 代码: bool GetNodeValue(out int Val) { Val = value; return true; } 参数和数组的数量变化 C# 中的数组使用关键字 params 进行传递。一个数组型的参数必须总是函数最右边的参数。只有一个参数可以是数组型。你可以传送任意数量的元素作为数组型的参数。看了下面的例子你可以更好的理解: 注意:使用数组是 C# 提供用于可选或可变数量参数的唯一途径。 例子: 复制内容到剪贴板 代码: void Func(params int[] array) { Console.WriteLine("number of elements {0}", array.Length); } 复制内容到剪贴板 代码: Func(); // 打印 0 Func(5); // 打印 1 Func(7,9); // 打印 2 Func(new int[] {3,8,10}); // 打印 3 int[] array = new int[8] {1,3,4,5,5,6,7,5}; Func(array); // 打印 8 运算符与表达式 运算符和表达式跟 C++ 中完全一致。然而同时也添加了一些新的有用的运算符。有些在这里进行了讨论。 is 运算符 is 运算符是用于检查操作数型是否相等或可以转换。is 运算符特别适合用于多态的情形。is 运算符使用两个操作数,其结果是布尔值。参考例子: 复制内容到剪贴板 代码: void function(object param) { if(param is ClassA) //做要做的事 else if(param is MyStruct) //做要做的事 } } as 运算符 as 运算符检查操作数的型是否可转换或是相等(as 是由 is 运算符完成的),如果是,则处理结果是已转换或已装箱的对象(如果操作数可以装箱为目标型,参考 装箱/拆箱)。如果对象不是可转换的或可装箱的,返回值为 null。看看下面的例子以更好的理解这个概念。 复制内容到剪贴板 代码: Shape shp = new Shape(); Vehicle veh = shp as Vehicle; // 返回 null,型不可转换 Circle cir = new Circle(); Shape shp = cir; Circle cir2 = shp as Circle; //将进行转换 object[] objects = new object[2]; objects[0] = "Aisha"; object[1] = new Shape(); string str; for(int i=0; i&< objects.Length; i++) { str = objects as string; if(str == null) Console.WriteLine("can not be converted"); else Console.WriteLine("{0}",str); } 复制内容到剪贴板 代码: Output: Aisha can not be converted 语句 除了些许附加的新语句和修改外,C# 的语句和 C++ 的基本一致。 以下是新的语句: foreach 用于迭代数组等集合。 例子: 复制内容到剪贴板 代码: foreach (string s in array) Console.WriteLine(s); lock 在线程中使代码块称为重点部分。 (译注:lock 关键字将语句块标记为临界区,方法是获取给定对象的互斥锁,执行语句,然后释放该锁。lock 确保当一个线程位于代码的临界区时,另一个线程不进入临界区。如果其他线程试图进入锁定的代码,则它将一直等待(即被阻止),直到该对象被释放。) checked/unchecked 用于数字操作中的溢出检查。 例子: 复制内容到剪贴板 代码: int x = Int32.MaxValue; x++; // 溢出检查 { x++; // 异常 } unchecked { x++; // 溢出 } 下面的语句已修改:(译注:原文如此,疑为作者笔误) Switch Switch 语句在 C# 中修改过。 1.现在在执行一条 case 语句后,程序流不能跳至下一 case 语句。之前在 C++ 中这是可以的。 例子: 复制内容到剪贴板 代码: int var = 100; switch (var) { case 100: Console.WriteLine(""); // 这里没有 break case 200: Console.WriteLine(""); break; } C++ 的输出: 复制内容到剪贴板 代码: 而在 C# 中你将得到一个编译时错误: 复制内容到剪贴板 代码: error CS0163: Control cannot fall through from one case label ('case 100:') to another 2.然而你可以像在 C++ 中一样这么用: 复制内容到剪贴板 代码: switch (var) { case 100: case 200: Console.WriteLine("100 or 200"); break; } 3.你还可以用常数变量作为 case 值: 例子: 复制内容到剪贴板 代码: const string WeekEnd = "Sunday"; const string WeekDay1 = "Monday"; .... string WeekDay = Console.ReadLine(); switch (WeekDay ) { case WeekEnd: Console.WriteLine("It's weekend!!"); break; case WeekDay1: Console.WriteLine("It's Monday"); break; } 委托 委托让我们可以把函数引用保存在变量中。这就像在 C++ 中使用 typedef 保存函数指针一样。 委托使用关键字 delegate 声明。看看这个例子,你就能理解什么是委托: 例子: 复制内容到剪贴板 代码: delegate int Operation(int val1, int val2); public int Add(int val1, int val2) { return val1 + val2; } public int Subtract (int val1, int val2) { return val1- val2; } public void Perform() { Operation Oper; Console.WriteLine("Enter + or - "); string optor = Console.ReadLine(); Console.WriteLine("Enter 2 operands"); string opnd1 = Console.ReadLine(); string opnd2 = Console.ReadLine(); int val1 = Convert.ToInt32 (opnd1); int val2 = Convert.ToInt32 (opnd2); if (optor == "+") Oper = new Operation(Add); else Oper = new Operation(Subtract); Console.WriteLine(" Result = {0}", Oper(val1, val2)); } 继承与多态 C# 只允许单一继承。多重继承可以通过接口达到。 例子: 复制内容到剪贴板 代码: class Parent{ } class Child : Parent 虚函数 虚函数在 C# 中同样是用于实现多态的概念的,除了你要使用 override 关键字在子中实现虚函数外。父使用同样的 virtual 关键字。每个重写虚函数的都使用 override 关键字。(译注:作者所说的“同样”,“除……外”都是针对 C# 和 C++ 而言的) 复制内容到剪贴板 代码: class Shape { public virtual void Draw() { Console.WriteLine("Shape.Draw") ; } } class Rectangle : Shape { public override void Draw() { Console.WriteLine("Rectangle.Draw"); } } class Square : Rectangle { public override void Draw() { Console.WriteLine("Square.Draw"); } } class MainClass { static void Main(string[] args) { Shape[] shp = new Shape[3]; Rectangle rect = new Rectangle(); shp[0] = new Shape(); shp[1] = rect; shp[2] = new Square(); shp[0].Draw(); shp[1].Draw(); shp[2].Draw(); } } Output: Shape.Draw Rectangle.Draw Square.Draw 使用“new”隐藏父函数 你可以隐藏基中的函数而在子中定义其新版本。关键字 new 用于声明新的版本。思考下面的例子,该例是上一例子的修改版本。注意输出,我用 关键字 new 替换了 Rectangle 中的关键字 override。 复制内容到剪贴板 代码: class Shape { public virtual void Draw() { Console.WriteLine("Shape.Draw") ; } } class Rectangle : Shape { public new void Draw() { Console.WriteLine("Rectangle.Draw"); } } class Square : Rectangle { //这里不用 override public new void Draw() { Console.WriteLine("Square.Draw"); } } class MainClass { static void Main(string[] args) { Console.WriteLine("Using Polymorphism:"); Shape[] shp = new Shape[3]; Rectangle rect = new Rectangle(); shp[0] = new Shape(); shp[1] = rect; shp[2] = new Square(); shp[0].Draw(); shp[1].Draw(); shp[2].Draw(); Console.WriteLine("Using without Polymorphism:"); rect.Draw(); Square sqr = new Square(); sqr.Draw(); } } Output: Using Polymorphism Shape.Draw Shape.Draw Shape.Draw Using without Polymorphism: Rectangle.Draw Square.Draw 多态性认为 Rectangle 的 Draw 方法是和 Shape 的 Draw 方法不同的另一个方法,而不是认为是其多态实现。所以为了防止父和子间的命名冲突,我们只有使用 new 修饰符。 注意:你不能在一个中使用一个方法的两个版本,一个用 new 修饰符,另一个用 override 或 virtual。就像在上面的例子中,我不能在 Rectangle 中增加另一个名为 Draw 的方法,因为它是一个 virtual 或 override 的方法。同样在 Square 中,我也不能重写 Shape 的虚方法 Draw。 调用基成员 如果子的数据成员和基中的有同样的名字,为了避免命名冲突,基成员和函数使用 base 关键字进行访问。看看下面的例子,基构造函数是如何调用的,而数据成员又是如何使用的。 复制内容到剪贴板 代码: public Child(int val) :base(val) { myVar = 5; base.myVar; } OR public Child(int val) { base(val); myVar = 5 ; base.myVar; } 前景展望 本文仅仅是作为 C# 语言的一个快速浏览,以便你可以熟悉该语言的一些特性。尽管我尝试用实例以一种简短而全面的方式讨论了 C# 几乎所有的主要概念,但我认为还是有很多内容需要增加和讨论的。 以后,我会增加更多的没有讨论过的命令和概念,包括事件等。我还想给初学者写一下怎么用 C# 进行 Windows 编程。 参考文献: 我们都知道的 MSDN Tom Archer 著,Inside C# Eric Gunnerson 著,A Programmer's Introduction to C# Karli Watson 著,Beginning C# O'Reilly(奥莱利出版),Programming C# 修改: 2003年6月12日:按引用传递/输入-输出参数一节中增加了 ref 关键字 2003年6月20日:为可选参数增加了一条注意事项,纠正了交错数组例子中赋值运算符的笔误 许可 本文及其任何关联的源代码和文件均以 The Code Project Open License (CPOL)执行。(译注:代码计划网站公开许可)
基本信息 作者: 臧萌 出版社:清华大学出版社 ISBN:9787302217831 上架时间:2010-3-30 出版日期:2010 年3月 开本:16开 其他详细信息查看:http://www.china-pub.com/196571 编辑推荐 Java编程老鸟潜心写作,奉献高效率的Java学习心得 完全站在没有编程经验读者的角度,手把手教会读者学习Java 配16小时多媒体教学视频,高效、直观 一一击破Java入门可能会遇到的难点和疑惑 抽丝剥茧,层层推进,让知识环环相扣,降低了学习的难度 通过大量的比喻、比、对比和图示等多种讲解方式,学习效果好 对Java语言的每个语法都提供了一个或多个例程讲解 大量使用流程图表示程序的执行过程,使用结构图表示程序的内部状态 每章最后都给出了典型的练习题,让读者及时练习,巩固提高,并提供了参考答案 目录 第1篇 Java语言基本语法 第1章 让自己的第一个Java程序跑起来 2 教学视频:19分钟 1.1 想要用Java改变这个世界吗? 2 1.1.1 Java有什么优势? 2 1.1.2 Java在哪儿? 3 1.2 准备好开始Java之旅 3 1.2.1 下载JDK 4 1.2.2 安装JDK 5 1.2.3 配置环境变量 6 1.2.4 测试环境是否安装成功 8 1.2.5 如果失败了怎么办? 9 1.3 让自己的第一个程序运行起来 10 1.3.1 编写自己的Hello World源程序 10 1.3.2 编译自己的HelloWorld程序 11 1.3.3 让代码运行起来 13 1.4 初探Hello World 14 1.4.1 (Class):Java世界中一物体 14 1.4.2 方法(Method):物体的功能 15 1.4.3 main()方法:所有Java程序执行的起点 15 .1.5 名词解释 16 1.5.1 JDK和Java平台 16 1.5.2 Java编译器(Java Compiler) 17 1.5.3 Java库(Java Class Libraries) 17 1.5.4 Java虚拟机(Java Virtual Machine) 17 1.5.5 HelloWorld的整个流程 17 1.6 小结:我们学会了编译和运行一个Java程序! 18 1.7 习题 19 第2章 搭建自己的集成开发环境 20 教学视频:31分钟 2.1 安装集成开发环境 20 2.1.1 集成开发环境有哪些 20 2.1.2 安装Eclipse 21 2.2 Eclipse界面介绍 23 2.2.1 启动Eclipse 23 2.2.2 Eclipse的Perspective 24 2.2.3 Eclipse的菜单 25 2.2.4 Eclipse的工具条 25 2.2.5 Eclipse辅助视图区 25 2.2.6 Eclipse中Package Explorer 26 2.2.7 Eclipse中的源代码编辑器 26 2.2.8 Eclipse的设置窗口 26 2.2.9 Eclipse中的其他视图 27 2.3 如何使用Eclipse 28 2.3.1 在Eclipse中创建自己的第一个项目 28 2.3.2 在Eclipse中编写HelloWorld程序 29 2.3.3 通过Eclipse运行Hello World 31 2.4 小结:Eclipse——功能很强大 32 2.5 习题 32 第3章 Java中的基本数据型和运算符 33 教学视频:1小时5分钟 3.1 Java中的基本数据型 33 3.1.1 基本数据型——编程语言中的数据原子 33 3.1.2 Java中的基本上数据型介绍 34 3.1.3 基本数据型值域 34 3.2 Java运算符 36 3.2.1 变量的概念 36 3.2.2 插曲:Java中的语句 37 3.2.3 创建一个变量和变量名的规范 37 3.2.4 Java中的基本运算符和表达式 39 3.2.5 Java中的布尔运算符 43 3.3 基本数据型运算的难点 47 3.3.1 强制型转换——小数哪里去了 48 3.3.2 型的转换在运算中悄悄进行 50 3.3.3 强制型转换最优先 52 3.3.4 等号其实不简单 52 3.3.5 小心使用浮点数进行比较 53 3.3.6 boolean和char 55 3.3.7 不要使用还没有创建出来的变量 57 3.3.8 String——char串起的项链 58 3.3.9 转义符——看不见写得出 61 3.4 小结:基本数据型—— Java中一切数据和运算的基础 63 3.5 习题 65 第4章 Java中的程序执行流程 67 教学视频:1小时57分钟 4.1 顺序执行 67 4.2 使用if-else让程序懂得判断 68 4.2.1 if语句 68 4.2.2 if语句的嵌套 71 4.2.3 if-else语句 73 4.2.4 if-else语句嵌套 75 4.3 使用while进行循环 76 4.3.1 使用while语句 76 4.3.2 使用do-while语句 79 4.4 使用for进行循环 80 4.4.1 自增和自减操作 80 4.4.2 for语句 82 4.4.3 for语句省略形式 84 4.5 语句中不能不说的事 84 4.5.1 小心复杂语句中创建的变量 85 4.5.2 别让循环次数给弄懵了 86 4.5.3 循环的嵌套 87 4.6 continue关键字与break关键字 88 4.6.1 continue关键字 88 4.6.2 break关键字 89 4.7 使用switch进行跳转 90 4.8 大例子 94 4.8.1 从控制台读取数据 94 4.8.2 结账程序中的循环 96 4.9 小结:Java不是一个直肠子 98 4.10 习题 99 第5章 数组 100 教学视频:35分钟 5.1 什么是数组 100 5.1.1 假设:如果需要逐个定义变量 100 5.1.2 数组初探 101 5.1.3 数组——物以聚 104 5.1.4 数组元素的值内有乾坤 105 5.1.5 创建数组的简洁语法 106 5.2 数组的“名”与“实” 107 5.2.1 “名”与“实”分离的数组 107 5.2.2 一“实”多“名”的数组 109 5.2.3 一“实”多“名”带来的困惑 111 5.3 多维数组 114 5.3.1 什么是多维数组 114 5.3.2 多维数组的实质 115 5.4 数组大练兵 123 5.4.1 轻松查询全班成绩 123 5.4.2 轻松查询全校成绩不在话下 124 5.4.3 杨辉三角 125 5.5 小结:方便快速的数组 129 5.6 习题 129 第2篇 Java语言高级语法 第6章 Java(Class)和对象(Object) 132 教学视频:59分钟 6.1 驾驶汽车向(Class)的世界进发 132 6.1.1 汽车带来的问题 132 6.1.1 的组成 134 6.1.3 使用自定义的Car 136 6.1.4 和对象 139 6.1.5 源文件的存放 141 6.1.5 理解引用 143 6.1.7 null关键字 145 6.2 巧妙使用中的属性 147 6.2.1 在中给每个变量一个初始值 147 6.2.2 定义自己的引用 147 6.2.3 使用点操作符的技巧 148 6.2.4 的数组 149 6.3 小结:Java其实是个和对象的世界 152 6.4 习题 153 第7章 Java中的方法——给汽车丰富多彩的功能 154 教学视频:2小时55分钟 7.1 方法:让汽车动开动 154 7.1.1 引出问题:开动汽车 154 7.1.2 那么,方法到底是什么呢? 155 7.1.3 方法调用过程初探 156 7.2 Java普通方法的组成部分 157 7.2.1 访问控制符:public 158 7.2.2 返回值和关键字void 158 7.2.3 方法名(Method Name) 159 7.2.4 参数列表(Parameter List) 159 7.2.5 方法体(Method Body) 160 7.2.6 方法串串烧 160 7.3 方法的参数:让汽车加速 161 7.3.1 方法的参数:让汽车可以加速 161 7.3.2 带参数的方法有何不同? 162 7.3.3 让方法有多个参数 163 7.4 返回值:汽车超速了吗? 164 7.4.1 写一个有返回值的方法 164 7.4.2 调用有返回值的方法 165 7.4.3 发生了什么?如何使用方法的返回值? 166 7.4.4 使用return结束方法 166 7.5 方法重载(overload):给汽车加速添个限制 168 7.5.1 什么是方法的签名 168 7.5.2 什么是重载?为什么要重载? 168 7.5.3 给汽车加个重载的方法 169 7.5.4 测试一下 169 7.5.5 重载容易引发误解的两个地方——返回型和形参名 170 7.5.6 重载中的最难点——参数匹配原则 171 7.6 使用的实例作为方法参数 172 7.6.1 超车方法:使用实例做参数 172 7.6.2 调用这个方法 173 7.6.3 发生了什么 174 7.7 加餐:局部变量和实例变量 175 7.7.1 什么是局部变量(Local Variable) 175 7.7.2 什么是实例变量(Instance Variable) 177 7.8 this关键字:指向对象自己的引用 177 7.8.1 发现问题:当实例变量和局部变量重名 177 7.8.2 经常深藏不露的this关键字 178 7.8.3 在方法中调用方法 179 7.9 构造方法(Constructor) 181 7.9.1 构造(Constructor)方法初探 181 7.9.2 如何使用构造方法 182 7.9.3 留个无参数的构造方法——给重要属性赋初始值 183 7.9.4 在构造方法中调用构造方法 184 7.10 方法大汇总 185 7.10.1 本例中用到的 186 7.10.2 使用例程将本章的知识穿起来 189 7.11 小结:多方位理解Java方法 191 7.12 习题 192 第8章 Java中的包(Package)命名习惯和注释 193 教学视频:43分钟 8.1 Java中的包(Package) 193 8.1.1 Java中的包 193 8.1.2 在Eclipse中使用包 194 8.1.3 天上掉下个package 197 8.1.4 包带来了什么? 197 8.2 import语句:化繁为简 200 8.2.1 import语句 200 8.2.2 一网打尽包中所有 201 8.2.3 import语句带来的小问题 202 8.2.4 默认引入的包 204 8.3 命名习惯大回顾 204 8.4 Java中的注释 205 8.4.1 使用双斜杠的单行注释 205 8.4.2 多行注释 206 8.4.3 Javadoc注释 206 8.5 小结:包让Java更清晰优雅 208 8.6 习题 209 第9章 再看数组、字符串和main()方法 210 教学视频:29分钟 9.1 数组也是 210 9.1.1 得到数组的长度 210 9.1.2 加餐:不可改变的final变量 211 9.1.3 多维数组的长度 212 9.1.4 一维数组的clone()方法 212 9.1.5 当数组型不再是基本数据型 214 9.1.6 多维数组的clone()方法 217 9.2 老朋友String 220 9.2.1 遍历String中的字符 220 9.2.2 获取字符串中的一部分 222 9.2.3 判断两个字符串是否相等 223 9.2.4 判断字符串的开头和结尾 225 9.2.5 分割字符串 225 9.2.6 在字符串中查找子字符串或字符 226 9.2.7 替换字符串中的内容 226 9.2.8 String对象——磐石刻字 227 9.3 String的最佳拍档——StringBuffer 227 9.3.1 StringBuffer:专业操纵字符 228 9.3.2 String和StringBuffer一个都不能少 229 9.4 最熟悉的陌生人:main()方法 229 9.4.1 main()方法的参数 229 9.4.2 static关键字 232 9.4.3 当方法遇到static关键字 233 9.5 小结:学会使用中的方法 235 9.6 习题 236 第10章 继承和多态 237 教学视频:1小时55分钟 10.1 继承——最优的解决方案 237 10.1.1 饭前水果:实例变量的访问控制符 237 10.1.2 一切还是从汽车开始 238 10.1.3 一车,一个 241 10.1.4 分开也有麻烦 244 10.1.5 使用继承——问题迎刃而解 245 10.1.6 使用Bus 248 10.1.7 Java中的单继承 248 10.1.8 Java中的图 249 10.1.9 万之祖——Object 250 10.2 子对象?父对象? 251 10.2.1 父随子行 251 10.2.2 当构造方法遇到继承 254 10.2.3 记得给一个无参数的构造方法 255 10.2.4 调用父中的构造方法 256 10.2.5 对象也会“变脸” 258 10.2.6 遵守语法,正确“变脸” 262 10.3 覆盖——与继承如影随形 264 10.3.1 当方法不再通用 264 10.3.2 覆盖——让众口不再难调 265 10.3.3 覆盖——到底调用了哪个方法 270 10.3.4 覆盖的语法不简单 272 10.3.5 更复杂的使用覆盖的情况 274 10.3.6 覆盖——不得不打开的潘多拉魔盒 276 10.3.7 使用super调用父中的方法和属性 278 10.4 多态(Polymorphism)以及其他 279 10.4.1 多态——运行方知结果 280 10.4.2 重载也不简单 280 10.4.3 使用多态构建车队 283 10.5 在多态的环境中拨开迷雾 284 10.5.1 神秘的Class 284 10.5.2 覆盖不再神秘 285 10.5.3 instanceof运算符——让对象告诉你它的是谁 286 10.6 小结:继承和多态让世界丰富多彩 287 10.7 习题 290 第11章 修饰符(Qualifier) 291 教学视频:26分钟 11.1 插曲:的组成部分的名字 291 11.2 中的修饰符 292 11.2.1 无修饰符 292 11.2.2 的可见性 293 11.2.3 final——让不可被继承 295 11.2.4 理解final关键字 296 11.2.5 总结:的修饰符 297 11.3 方法的修饰符 297 11.3.1 方法的访问控制符 298 11.3.2 public:没有限制的修饰符 299 11.3.3 protected:仅对子和同包的可见 300 11.3.4 默认控制符:仅在本包中可见 301 11.3.5 private:仅对本可见 303 11.3.6 理解4个访问控制符 304 11.3.7 访问控制符可见性汇总 306 11.3.8 访问控制符带来的覆盖问题 306 11.3.9 final:不允许方法被覆盖 310 11.3.10 重温静态方法 311 11.3.11 静态方法——范围里的概念 312 11.3.12 静态方法何以为“静态” 314 11.4 变量的修饰符 316 11.4.1 变量方法皆成员 317 11.4.2 变量的访问控制符 317 11.4.3 使用private修饰的成员变量 318 11.4.4 使用private,然后呢? 320 11.4.5 变量的覆盖 322 11.4.6 使用final修饰成员变量 325 11.4.7 静态成员变量 326 11.4.8 局部变量的修饰符 326 11.4.9 当final遇到引用型成员变量 327 11.5 小结:修饰符作用大 328 11.6 习题 330 第12章 接口 331 教学视频:29分钟 12.1 自行车带来的问题 331 12.1.1 记录马路上的车辆 331 12.1.2 引发问题的自行车 335 12.1.3 仔细分析recordTransport()方法 338 12.2 初用接口 339 12.2.1 准备好需要用到的 339 12.2.2 认识接口的代码组成 340 12.2.3 什么是接口 341 12.2.4 使用接口仅需一步——实现接口 342 12.2.5 接口——让集多重型于一身 344 12.2.6 简化recordTransport()方法 347 12.3 再探接口 349 12.3.1 重温上节中的程序 349 12.3.2 面向接口编程 351 12.3.3 话说“抽象” 353 12.3.4 接口大瘦身 355 12.3.5 实现多个接口 355 12.3.6 接口中的变量 357 12.3.7 接口的继承 358 12.3.8 匹配抽象方法中的型 359 12.3.9 空接口 361 12.4 小结:接口的难点在于何时使用 362 12.5 习题 364 第13章 抽象和内部 365 教学视频:26分钟 13.1 抽象(Abstract Class) 365 13.1.1 不知道怎么打招呼的Person 365 13.1.2 当中有了抽象方法 367 13.1.3 抽象语法详解 368 13.1.4 理解抽象的作用 369 13.2 内部的分(Inner Class) 370 13.2.1 成员内部 370 13.2.2 局部内部 372 13.3 成员内部 374 13.3.1 使用成员内部 374 13.3.2 成员内部的修饰符 375 13.3.3 在外部使用内部 376 13.3.4 非静态内部的特性 378 13.3.5 外部访问成员内部中的属性 382 13.3.6 静态成员内部 383 13.4 局部内部 384 13.4.1 局部内部之“局部” 385 13.4.2 局部内部之“内部” 386 13.4.3 使用局部内部 388 13.5 匿名内部(Anonymous inner classes) 389 13.5.1 准备工作 389 13.5.2 匿名内部的语法 389 13.5.3 通过接口使用匿名 390 13.5.4 通过抽象使用匿名 391 13.6 ,这样一路走来 391 13.7 小结:丰富多彩的 395 13.8 习题 397 第14章 Java的异常处理机制 398 教学视频:36分钟 14.1 认识异常 398 14.1.1 异常什么时候发生 398 14.1.2 异常是什么 401 14.1.3 Java异常机制的流程 401 14.2 抛出异常 403 14.2.1 异常的父——Throwable 403 14.2.2 在代码中使用throw抛出一个异常 404 14.2.3 在方法声明中使用throws 407 14.2.4 构造自定义异常 409 14.2.5 使用自定义异常 410 14.3 异常的传递 411 14.3.1 抛出最确切的异常型 411 14.3.2 Java异常的传递 412 14.3.3 图说Java异常的传递 414 14.4 异常的处理 418 14.4.1 把异常捉住 418 14.4.2 图说异常处理流程 421 14.4.3 多异常,一并处理 424 14.4.4 try-catch-finally语句 426 14.4.5 try-finally语句 431 14.4.6 好好利用catch语句 432 14.5 异常的型 433 14.5.1 3个的继承关系 433 14.5.2 必须处理的Exception 434 14.5.3 灵活掌握的RuntimeException 434 14.5.4 不用处理的Error 435 14.6 小结:终止错误的蔓延 435 14.7 习题 437 第15章 多线程编程 438 教学视频:1小时14分钟 15.1 线程——执行代码的机器 438 15.1.1 线程——执行代码的基本单位 438 15.1.2 演奏会模型 440 15.2 Java中的线程编程 443 15.2.1 线程Thread 443 15.2.2 覆盖Thread的run()方法 444 15.2.3 使用Runnable接口 446 15.2.4 两个线程 448 15.3 深入学习Thread 449 15.3.1 线程的名字 449 15.3.2 得到当前的线程 451 15.3.3 让线程“沉睡” 453 15.4 多个线程的故事 457 15.4.1 一个有多个线程的程序 457 15.4.2 复印社模型 459 15.4.3 一个简单的复印社例程 461 15.5 多个线程的同步 463 15.5.1 线程同步之synchronized关键字 463 15.5.2 深入学习synchronized关键字 468 15.5.3 静态同步方法 469 15.5.4 非静态的同步方法 472 15.5.5 银行的麻烦——账户乱套了 474 15.5.6 多角度理解同步方法 481 15.5.7 闲话同步方法的使用 484 15.5.8 同步代码块 485 15.5.9 锁(Lock) 486 15.5.10 线程同步之wait()和notify()方法 488 15.5.11 wait和notify的顺序 491 15.6 小结:线程——代码执行器 494 15.7 习题 495 第3篇 Java语言编程进阶 第16章 如何学习本篇 498 教学视频:15分钟 16.1 多想多写多练 498 16.2 术业有专攻 498 16.3 拆分问题,逐个击破 500 16.4 阅读Javadoc 500 16.5 小结:大练兵马上开始 506 16.6 习题 507 第17章 编程常用知识 508 教学视频:18分钟 17.1 再谈对象的比较 508 17.1.1 hashcode()方法 508 17.1.2 equals()方法 509 17.1.3 对象的比较equals()方法 509 17.2 Java中的集合框架 510 17.2.1 集合框架中的接口 510 17.2.2 List接口 511 17.2.3 使用ArrayList 512 17.2.4 Set接口 516 17.2.5 使用HashSet 517 17.2.6 List与Set 518 17.3 泛型简介 518 17.3.1 没有泛型时的程序 519 17.3.2 使用泛型——避免强制型转 520 17.4 Map接口 522 17.4.1 认识Map 522 17.4.2 使用HashMap 523 17.5 字符集和编码 524 17.5.1 字符集 524 17.5.2 编码 525 17.5.3 关于字符集的小程序 526 17.6 小结:编程需要打好基础 529 17.7 习题 530 第18章 Java文件编程和Java文件I/O 531 教学视频:9分钟 18.1 Java中的文件编程 531 18.1.1 File 531 18.1.2 创建和删除文件 532 18.1.3 列出文件和文件夹 533 18.1.4 重命名文件 535 18.2 Java的I/O编程 536 18.2.1 理解Java中的Stream 536 18.2.2 向文件中写入数据 538 18.2.3 从文件中读取数据 539 18.2.4 从控制台读取数据 541 18.2.5 使用输出流写入数据 543 18.2.6 使用输入流读取数据 545 18.3 小结:Java中的文件和输入输出机制 546 18.4 习题 547 第19章 Java Socket编程 548 教学视频:8分钟 19.1 IP地址和端口号 548 19.1.1 IP地址——计算机的标识 548 19.1.2 端口号——通信的窗口 549 19.1.3 网络,IP地址和端口号 551 19.2 Java TCP编程 551 19.2.1 数据传输协议 552 19.2.2 TCP的数据传输模式 552 19.2.3 第一个TCP小程序 553 19.3 Java UDP编程 557 19.3.1 UDP的数据传输模式 557 19.3.2 使用UDP协议收发数据 558 19.3.3 TCP和UDP的区别 560 19.4 小结:让程序伸向整个网络 561 19.5 习题 561 第20章 Java Swing编程 562 教学视频:14分钟 20.1 Java Swing编程简介 562 20.1.1 图形用户界面编程简介 562 20.1.2 组件 563 20.1.3 布局管理器(Layout Manager) 563 20.1.4 事件处理(Event Handling) 564 20.2 Swing基本组件 565 20.2.1 窗口(JFrame) 565 20.2.2 Swing的线程 567 20.2.3 Swing组件的鼻祖——JComponent 567 20.2.4 Swing面板 568 20.2.5 Swing中的标签 568 20.2.6 Swing中的文本框 570 20.2.7 Swing中的文本域 571 20.2.8 Swing中的组合框 572 20.2.9 Swing中的按钮 573 20.3 Swing的布局管理器 574 20.3.1 最简单的FlowLayout 574 20.3.2 东南西北中之BorderLayout 574 20.3.3 平均分割之——GridLayout 576 20.3.4 最强大的布局管理器——GridBagLayout 577 20.3.5 使用多个布局管理器 579 20.4 Swing的事件处理 581 20.4.1 事件的传递和封装 581 20.4.2 事件监听器——事件的处理者 582 20.4.3 Swing事件处理的机制 584 20.4.4 事件监听器的编写 586 20.4.5 如何学习更多的事件 588 20.5 小结:从此不再依赖控制台 588 20.6 习题 588 第21章 编程,需要的是想象力和恒心 589 教学视频:13分钟 21.1 编程的前奏 589 21.1.1 细数手中的积木 589 21.1.2 发挥想象力 590 21.1.3 确定程序的功能 591 21.2 聊天窗口程序 591 21.2.1 聊天程序设计 591 21.2.2 设计程序运行效果 593 21.2.3 UDP消息收发模块 595 21.2.4 图形用户界面模块 598 21.2.5 消息处理模块 600 21.2.6 一个更通用的聊天程序 601 21.3 小结:编程是必不可少的锻炼 602 21.4 习题 602 第22章 JDBC入门 603 教学视频:11分钟 22.1 JDBC的基本API 603 22.1.1 JDBC是什么 603 22.1.2 DriverManager——驱动管理器 605 22.1.3 Connection接口 606 22.1.4 Statement接口 606 22.1.5 PreparedStatement接口 606 22.1.6 ResultSet接口 607 22.1.7 JDBC-ODBC桥 607 22.2 一个操作数据库的简单程序 608 22.2.1 程序的执行结果 608 22.2.2 程序设计与模块划分 609 22.2.3 准备好数据源 610 22.2.4 数据库操作模块的实现 610 22.2.5 图形用户界面模块的实现 611 22.3 小结:强大的JDBC标准 613 22.4 习题 613

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值