类的作用-30

Java 静态内部类作用？

那个叫内部类

定义在一个类内部的类叫内部类，包含内部类的类称为外部类。内部类可以声明public、protected、private等访问限制，可以声明为abstract的供其他内部类或外部类继承与扩展，或者声明为static、final的，也可以实现特定的接口。static的内部类行为上象一个独立的类，非static在行为上类似类的属性或方法且禁止声明static的方法。内部类可以访问外部类的所有方法与属性，但static的内部类只能访问外部类的静态属性与方法。

外部类按常规的类访问方式使用内部类，唯一的差别是外部类可以访问内部类的所有方法与属性，包括私有方法与属性。如：

pinner p = new pinner();。

p.index = 20;。

p.Print();。

---- 这种方式适合外部类的非static方法；

pouter po = new pouter();。

pinner pi = po.new pinner();。

pi.index = 40;。

pi.Print();。

---- 这种方式适合外部类的static方法；

内部类类似外部类的属性，因此访问内部类对象时总是需要一个创建好的外部类对象。内部类对象通过‘外部类名.this.xxx’的形式访问外部类的属性与方法。如：

System.out.println("Print in inner Outer.index=" + pouter.this.index);。

System.out.println("Print in inner Inner.index=" + this.index);。

如果需要在其他类中访问内部类，可以使用：

(1)外部类提供创建内部类的方法供其他类使用。如：

// 外部类

pinner getInner()。

{

return new pinner();。

}

// 其他类

pouter.pinner pi = po.getInner();。

pi.Print();。

(2)直接创建内部类的对象。如：

pouter po = new pouter();。

pouter.pinner pi = po.new pinner();。

pi.Print();。

内部类可以声明在外部类的方法中或语句块中。如果内部类需要访问包含它的外部类方法或语句块的局部变量或参数，则该局部变量或参数必须是final的。外部类的其他方法、其他类无法访问声明在方法内部或块内部的内部类。

如果一个类继承内部类，则创建该类的对象时需提供一个外部类的对象作为构造方法的参数。如：

class Car

class Wheel。

{

}

class SuperWheel extends Car.Wheel。

SuperWheel(Car car)。

{

car.super();。

}

public static void main(String [] args)。

{

Car car = new Car();。

SuperWheel wl = new SuperWheel(car);。

}

如果创建命名的内部类没有多少实际意义时，可以创建匿名的内部类。比如使用内部类实现接口的功能(如事件处理器、适配器等)，而功能的差异较大，需要根据实际的情况创建相应的内部类时，可以使用匿名内部类。简单的示例如下：

interface WebView。

void doGet();。

class A

WebView ShowName()。

{

return new WebView()。

{

void doGet()。

{

System.out.println("Name");。

} 。

};

}

WebView ShowCode()。

{

return new WebView()。

{

void doGet()。

{

System.out.println("Code");。

} 。

};

}

最后，JAVA 内部类还有一个作用，那就是实现JAVA的多继承。JAVA本身是不允许多继承的，如果我们想一个类继承多个基类，就可以使用内部类。通过内部类分别继承一个基类，外部类创建内部类的对象，并使用内部类的方法，变相地实现了多继承。

C++类，详解

1、变值权限修饰作用，在定义内部类的时候，可以在其前面加上一个权限修饰符static。此时这个内部类就变为了静态内部类。

2、在某些特殊的情况下，少了这个静态内部类还真是不行。如在进行代码程序测试的时候，如果在每一个Java源文件中都设置一个主方法(主方法是某个应用程序的入口，必须具有)，那么会出现很多额外的代码。

3、最主要的时这段主程序的代码对于Java文件来说，只是一个形式，其本身并不需要这种主方法。但是少了这个主方法又是万万不行的。在这种情况下，就可以将主方法写入到静态内部类中，从而不用为每个Java源文件都设置一个类似的主方法。

这对于代码测试是非常有用的。在一些中大型的应用程序开发中，则是一个常用的技术手段。

扩展资料

例如：

对于两个类，拥有相同的方法：

class People{

run();

interface Machine{。

run();

此时有一个robot类：

class Robot extends People implement Machine.。

此时run()不可直接实现。

interface Machine{。

void run();

class Person{

void run(){

System.out.println("run");。

class Robot extends Person{。

private class MachineHeart implements Machine{。

public void run(){。

System.out.println("heart run");。

public void run(){。

System.out.println("Robot run");。

Machine.getMachine(){returnnew MachineHeart();。

class Test{

publicstaticvoid main(String[] args){。

Robot robot=new Robot();。

Machine m=robot.getMachine();。

m.run();

robot.run();

参考资料来源：百度百科-静态内部类。

茶叶的种类、作用？

推荐先看书系统学习下吧《C++程序设计》

一、C++类的定义

C++中使用关键字 class 来定义类, 其基本形式如下:。

class 类名

public:

//行为或属性

protected:

//行为或属性

private:

//行为或属性

};

示例:

定义一个点(Point)类, 具有以下属性和方法:。

■ 属性: x坐标, y坐标

■ 方法: 1.设置x,y的坐标值; 2.输出坐标的信息。

实现代码:

class Point

public:

void setPoint(int x, int y);。

void printPoint();。

private:

int xPos;

int yPos;

};

代码说明:

上段代码中定义了一个名为 Point 的类, 具有两个私密属性, int型的xPos和yPos, 分别用来表示x点和y点。

在方法上, setPoint 用来设置属性, 也就是 xPos 和 yPos 的值; printPoint 用来输出点的信息。

1 数据抽象和封装

抽象是通过特定的实例抽取共同特征以后形成概念的过程。一个对象是现实世界中一个实体的抽象，一个类是一组对象的抽象。

封装是将相关的概念组成一个单元，然后通过一个名称来引用它。面向对象封装是将数据和基于数据的操作封装成一个整体对象，对数据的访问或修改只能通过对象对外提供的接口进行。

2 类定义

几个重要名词：

(1) 类名

遵循一般的命名规则; 字母，数字和下划线组合，不要以数字开头。

(2) 类成员

类可以没有成员，也可以定义多个成员。成员可以是数据、函数或类型别名。所有的成员都必须在类的内部声明。

没有成员的类是空类，空类也占用空间。

class People

};

sizeof(People) = 1; 。

(3) 构造函数

构造函数是一个特殊的、与类同名的成员函数，用于给每个数据成员设置适当的初始值。

(4) 成员函数

成员函数必须在类内部声明，可以在类内部定义，也可以在类外部定义。如果在类内部定义，就默认是内联函数。

3 类定义补充

3.1 可使用类型别名来简化类。

除了定义数据和函数成员之外，类还可以定义自己的局部类型名字。

使用类型别名有很多好处，它让复杂的类型名字变得简单明了、易于理解和使用，还有助于程序员清楚地知道使用该类型的真实目的。

class People

{

public:

typedef std::string phonenum; //电话号码类型。

phonenum phonePub; //公开号码。

private:

phonenum phonePri;//私人号码。

};

3.2 成员函数可被重载

可以有多个重载成员函数，个数不限。

3.3 内联函数

有三种：

（1）直接在类内部定义。

（2）在类内部声明，加上inline关键字，在类外部定义。

（3）在类内部声明，在类外部定义，同时加上inline关键字。注意：此种情况下，内联函数的定义通常应该放在类定义的同一头文件中，而不是在源文件中。这是为了保证内联函数的定义在调用该函数的每个源文件中是可见的。

3.4 访问限制

public，private，protected 为属性/方法限制的关键字。

3.5 类的数据成员中不能使用 auto、extern和register等进行修饰, 也不能在定义时进行初始化。

如 int xPos = 0; //错;。

例外：

静态常量整型（包括char,bool）数据成员可以直接在类的定义体中进行初始化，例如：

static const int ia= 30; 。

4 类声明与类定义

4.1 类声明(declare)。

class Screen;

在声明之后，定义之前，只知道Screen是一个类名，但不知道包含哪些成员。只能以有限方式使用它，不能定义该类型的对象，只能用于定义指向该类型的指针或引用，声明（不是定义）使用该类型作为形参类型或返回类型的函数。

void Test1(Screen& a){};。

void Test1(Screen* a){};。

4.2 类定义(define)。

在创建类的对象之前，必须完整的定义该类，而不只是声明类。所以，类不能具有自身类型的数据成员，但可以包含指向本类的指针或引用。

class LinkScreen。

public:

Screen window;

LinkScreen* next;。

LinkScreen* prev;。

}; //注意，分号不能丢

因为在类定义之后可以接一个对象定义列表，可类比内置类型，定义必须以分号结束：

class LinkScreen{ /* ... */ };。

class LinkScreen{ /* ... */ } scr1,scr2; 。

5 类对象

定义类对象时，将为其分配存储空间。

Sales_item item; //编译器分配了足以容纳一个 Sales_item 对象的存储空间。item 指的就是那个存储空间。

6 隐含的 this 指针

成员函数具有一个附加的隐含形参，即 this指针，它由编译器隐含地定义。成员函数的函数体可以显式使用 this 指针。

6.1 何时使用 this 指针。

当我们需要将一个对象作为整体引用而不是引用对象的一个成员时。最常见的情况是在这样的函数中使用 this：该函数返回对调用该函数的对象的引用。

class Screen

...

public:

Screen& set(char);。

};

Screen& Screen::set(char c) 。

contents[cursor] = c;。

return *this;

7 类作用域

每个类都定义了自己的作用域和唯一的类型。

类的作用域包括：类的内部（花括号之内）, 定义在类外部的成员函数的参数表(小括号之内)和函数体（花括号之内）。

class Screen

{

//类的内部

...

};

//类的外部

char Screen::get(index r, index c) const。

index row = r * width; // compute the row location。

return contents[row + c]; // offset by c to fetch specified character。

注意：成员函数的返回类型不一定在类作用域中。可通过 类名::来判断是否是类的作用域，::之前不属于类的作用域，::之后属于类的作用域。例如。

Screen:: 之前的返回类型就不在类的作用域，Screen:: 之后的函数名开始到函数体都是类的作用域。

class Screen

{

public:

typedef std::string::size_type index; 。

index get_cursor() const; 。

};

Screen::index Screen::get_cursor() const //注意：index前面的Screen不能少。

{

return cursor; 。

}

该函数的返回类型是 index，这是在 Screen 类内部定义的一个类型名。在类作用域之外使用，必须用完全限定的类型名 Screen::index 来指定所需要的 index 是在类 Screen 中定义的名字。

二 构造函数

构造函数是特殊的成员函数，用来保证每个对象的数据成员具有合适的初始值。

构造函数名字与类名相同，不能指定返回类型（也不能定义返回类型为void），可以有0-n个形参。

在创建类的对象时，编译器就运行一个构造函数。

1 构造函数可以重载

可以为一个类声明的构造函数的数量没有限制，只要每个构造函数的形参表是唯一的。

class Sales_item;。

public:

Sales_item(const std::string&); 。

Sales_item(std::istream&); 。

Sales_item(); //默认构造函数。

};

2 构造函数自动执行

只要创建该类型的一个对象，编译器就运行一个构造函数：

Sales_item item1("0-201-54848-8");。

Sales_item *p = new Sales_item();。

第一种情况下，运行接受一个 string 实参的构造函数，来初始化变量item1。

第二种情况下，动态分配一个新的 Sales_item 对象，通过运行默认构造函数初始化该对象。

3 构造函数初始化式

与其他函数一样，构造函数具有名字、形参表和函数体。

与其他函数不同的是，构造函数可以包含一个构造函数初始化列表：

Sales_item::Sales_item(const string &book): isbn(book), units_sold(0), revenue(0.0)。

{ }

构造函数初始化列表以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个数据成员后面跟一个放在圆括号中的初始化式。

构造函数可以定义在类的内部或外部。构造函数初始化只在构造函数的定义中指定。

构造函数分两个阶段执行：(1)初始化阶段；(2)普通的计算阶段。初始化列表属于初始化阶段(1)，构造函数函数体中的所有语句属于计算阶段(2)。

初始化列表比构造函数体先执行。不管成员是否在构造函数初始化列表中显式初始化，类类型的数据成员总是在初始化阶段初始化。

3.1 哪种类需要初始化式

const 对象或引用类型的对象，可以初始化，但不能对它们赋值，而且在开始执行构造函数的函数体之前要完成初始化。

初始化 const 或引用类型数据成员的唯一机会是构造函数初始化列表中，在构造函数函数体中对它们赋值不起作用。

没有默认构造函数的类类型的成员，以及 const 或引用类型的成员，必须在初始化列表中完成初始化。

class ConstRef 。

{

public:

ConstRef(int ii); 。

private:

int i;

const int ci;

int &ri;

};

ConstRef::ConstRef(int ii) 。

i = ii; // ok 。

ci = ii; // error。

ri = i; //

应该这么初始化：

ConstRef::ConstRef(int ii): i(ii), ci(i), ri(ii) { } 。

3.2 成员初始化的次序

每个成员在构造函数初始化列表中只能指定一次。重复初始化，编译器一般会有提示。

成员被初始化的次序就是定义成员的次序，跟初始化列表中的顺序无关。

3.3 初始化式表达式

初始化式可以是任意表达式

Sales_item(const std::string &book, int cnt, double price): isbn(book), units_sold(cnt), revenue(cnt * price) { }。

3.4 类类型的数据成员的初始化式。

初始化类类型的成员时，要指定实参并传递给成员类型的一个构造函数，可以使用该类型的任意构造函数。

Sales_item(): isbn(10, '9'), units_sold(0), revenue(0.0) {}。

3.5 类对象的数据成员的初始化。

在类A的构造函数初始化列表中没有显式提及的每个成员，使用与初始化变量相同的规则来进行初始化。

类类型的数据成员，运行该类型的默认构造函数来初始化。

内置或复合类型的成员的初始值依赖于该类对象的作用域：在局部作用域中不被初始化，在全局作用域中被初始化为0。假设有一个类A，

class A

public:

int ia;

B b;

};

A类对象A a;不管a在局部作用域还是全局作用域，b使用B类的默认构造函数来初始化，ia的初始化取决于a的作用域，a在局部作用域，ia不被初始化，a在全局作用域，ia初始化0。

4 默认构造函数

不含形参的构造函数就是默认构造函数。

只要定义一个对象时没有提供初始化式，就使用默认构造函数。如： A a;。

为所有形参提供默认实参的构造函数也定义了默认构造函数。例如：

class A

public:

A(int a=1,char c =''){}。

private:

int ia;

char c1;

};

4.1 合成的默认构造函数

只有当一个类没有定义构造函数时，编译器才会自动生成一个默认构造函数。

一个类只要定义了一个构造函数，编译器也不会再生成默认构造函数。

建议：

如果定义了其他构造函数，也提供一个默认构造函数。

如果类包含内置或复合类型（如 int& 或 string*）的成员，它应该定义自己的构造函数来初始化这些成员。每个构造函数应该为每个内置或复合类型的成员提供初始化。

5 隐式类类型转换

5.1 只含单个形参的构造函数能够实现从形参类型到该类类型的一个隐式转换。

class A

public:

A(int a)

ia =a;

bool EqualTo(const A& a)。

return ia == a.ia;。

private:

int ia;

};

A a(1);

bool bEq = false;。

bEq = a.EqualTo(1);//参数为1，实现从int型到A的隐式转换。

5.2抑制由构造函数定义的隐式转换。

通过将构造函数声明为 explicit，来防止在需要隐式转换的上下文中使用构造函数：

class A

public:

explicit A(int a )。

ia =a;

bool EqualTo(const A& a)。

return ia == a.ia;。

private:

int ia;

};

通常，除非有明显的理由想要定义隐式转换，否则，单形参构造函数应该为 explicit。将构造函数设置为 explicit 可以避免错误。

三 复制控制

1 复制构造函数

1.1 几个要点

(1) 复制构造函数

复制构造函数是一种特殊构造函数，只有1个形参，该形参（常用 const &修饰）是对该类类型的引用。

class Peopel

public:

Peopel();//默认构造函数。

Peopel(const Peopel&);//复制构造函数。

~Peopel();//析构函数。

};

当定义一个新对象并用一个同类型的对象对它进行初始化时，将显式使用复制构造函数。

Peopel a1; Peopel a2 = a1;。

当将该类型的对象传递给函数或函数返回该类型的对象时，将隐式使用复制构造函数。

Peopel Func(Peopel b){...}。

(2)析构函数

析构函数是构造函数的互补：当对象超出作用域或动态分配的对象被删除时，将自动应用析构函数。

析构函数可用于释放构造对象时或在对象的生命期中所获取的资源。

不管类是否定义了自己的析构函数，编译器都自动执行类中非 static 数据成员的析构函数。

(3) 复制控制

复制构造函数、赋值操作符和析构函数总称为复制控制。编译器自动实现这些操作，但类也可以定义自己的版本。

(4) 两种初始化形式

C++ 支持两种初始化形式：直接初始化和复制初始化。直接初始化将初始化式放在圆括号中，复制初始化使用 = 符号。

对于内置类型，例如int, double等，直接初始化和复制初始化没有区别。

对于类类型：直接初始化直接调用与实参匹配的构造函数；复制初始化先使用指定构造函数创建一个临时对象，然后用复制构造函数将那个临时对象复制到正在创建的对象。直接初始化比复制初始化更快。

(5)形参和返回值

当形参或返回值为类类型时，由该类的复制构造函数进行复制。

(6)初始化容器元素

复制构造函数可用于初始化顺序容器中的元素。例如：

vector<string> svec(5);。

编译器首先使用 string 默认构造函数创建一个临时值，然后使用复制构造函数将临时值复制到 svec 的每个元素。

(7)构造函数与数组元素

如果没有为类类型数组提供元素初始化式，则将用默认构造函数初始化每个元素。

如果使用常规的花括号括住的数组初始化列表来提供显式元素初始化式，则使用复制初始化来初始化每个元素。根据指定值创建适当类型的元素，然后用复制构造函数将该值复制到相应元素：

Sales_item primer_eds[] = { string("0-201-16487-6"),。

string("0-201-54848-8"),。

string("0-201-82470-1"),。

Sales_item()

};

1.2 合成的复制构造函数

(1)合成的复制构造函数

如果没有定义复制构造函数，编译器就会为我们合成一个。

合成复制构造函数的行为是，执行逐个成员初始化，将新对象初始化为原对象的副本。

逐个成员初始化：合成复制构造函数直接复制内置类型成员的值，类类型成员使用该类的复制构造函数进行复制。

例外：如果一个类具有数组成员，则合成复制构造函数将复制数组。复制数组时合成复制构造函数将复制数组的每一个元素。

1.3 定义自己的复制构造函数。

(1) 只包含类类型成员或内置类型（但不是指针类型）成员的类，无须显式地定义复制构造函数，也可以复制。

class Peopel

public:

std::string name;。

unsigned int id;。

unsigned int age;。

std::string address;。

};

(2) 有些类必须对复制对象时发生的事情加以控制。

例如，类有一个数据成员是指针，或者有成员表示在构造函数中分配的其他资源。而另一些类在创建新对象时必须做一些特定工作。这两种情况下，都必须定义自己的复制构造函数。

最好显式或隐式定义默认构造函数和复制构造函数。如果定义了复制构造函数，必须定义默认构造函数。

1.4 禁止复制

有些类需要完全禁止复制。例如，iostream 类就不允许复制。延伸：容器内元素不能为iostream。

为了防止复制，类必须显式声明其复制构造函数为 private。

2 赋值操作符

与复制构造函数一样，如果类没有定义自己的赋值操作符，则编译器会合成一个。

(1)重载赋值操作符

Sales_item& operator=(const Sales_item &);。

(2)合成赋值操作符

合成赋值操作符会逐个成员赋值：右操作数对象的每个成员赋值给左操作数对象的对应成员。除数组之外，每个成员用所属类型的常规方式进行赋值。对于数组，给每个数组元素赋值。

(3)复制和赋值常一起使用

一般而言，如果类需要复制构造函数，它也会需要赋值操作符。

3 析构函数

构造函数的用途之一是自动获取资源；与之相对的是，析构函数的用途之一是回收资源。除此之外，析构函数可以执行任意类设计者希望在该类对象的使用完毕之后执行的操作。

(1) 何时调用析构函数

撤销（销毁）类对象时会自动调用析构函数。

变量（类对象）在超出作用域时应该自动撤销（销毁）。

动态分配的对象(new A)只有在指向该对象的指针被删除时才撤销（销毁）。

撤销（销毁）一个容器（不管是标准库容器还是内置数组）时，也会运行容器中的类类型元素的析构函数（容器中的元素总是从后往前撤销）。

(2)何时编写显式析构函数

如果类需要定义析构函数，则它也需要定义赋值操作符和复制构造函数，这个规则常称为三法则：如果类需要析构函数，则需要所有这三个复制控制成员。

(3)合成析构函数

合成析构函数按对象创建时的逆序撤销每个非 static 成员，因此，它按成员在类中声明次序的逆序撤销成员。

对于每个类类型的成员，合成析构函数调用该成员的析构函数来撤销对象。

合成析构函数并不删除指针成员所指向的对象。 所以，如果有指针成员，一定要定义自己的析构函数来删除指针。

析构函数与复制构造函数或赋值操作符之间的一个重要区别：即使我们编写了自己的析构函数，合成析构函数仍然运行。

四 友元

友元机制允许一个类将对其非公有成员的访问权授予指定的函数或类。

友元可以出现在类定义的内部的任何地方。

友元不是授予友元关系的那个类的成员，所以它们不受声明出现部分的访问控制影响。

建议：将友元声明成组地放在类定义的开始或结尾。

1 友元类

class Husband

public:

friend class Wife;。

private:

double money;//钱是老公私有的，别人不能动，但老婆除外。

};

class Wife

public:

void Consume(Husband& h)。

h.money -= 10000;//老婆可以花老公的钱。

};

Husband h;

Wife w;

w.Consume(h);

2 使其他类的成员函数成为友元。

class Husband; //1.声明Husband 。

class Wife //2.定义Wife类 。

public:

void Consume(Husband& h);。

};

class Husband //3.定义Husband类。

public:

friend void Wife::Consume(Husband& h);//声明Consume函数。

private:

double money;//钱是老公私有的，别人不能动，但老婆除外。

};

void Wife::Consume(Husband& h) //4.定义Consume函数。

h.money -= 10000;//老婆可以花老公的钱。

注意类和函数的声明和定义的顺序：

(1)声明类Husband

(2)定义类Wife，声明Consume函数。

(3)定义类Husband

(4)定义Consume函数。

哪位大侠能简单通俗的给我讲一下下面三个类的作用和用法啊，API文档上的说明太专业了，我看不太懂

主要品种有绿茶、红茶、乌龙茶、花茶、白茶、黄茶。

茶叶的分类

1.以色泽(或制作工艺)分类: 。

茶类名 制作特色 代表产品

绿茶 不发酵的茶(发酵度为零) 龙井茶,碧螺春 。

黄茶 徽发酵的茶(发酵度为10-20m） 白牡丹,白毫银针,安吉白荣 。

白茶 轻度发酵的茶(发酵度为20-30m） 君山银针 。

青茶 半发酵的茶(发酵度为30-60m） 铁观音,文山包种茶，冻顶乌龙茶 。

红茶 全发酵的茶(发酵度为80-90m） 祁门红茶，荔枝红茶 。

黑茶 后发酵的茶(发酵度为100m） 六堡茶,普洱茶 。

2.以季节分类:

①春茶----是指当年3月下旬到5月中旬之前采制的茶叶。春季温度适中，雨量充份，再加上茶树经过了半年冬季的修养生息，使得春季茶芽肥硕，色泽翠绿，叶质柔软，且含有丰富的维生素，特别是氨基酸。不但使春茶滋味鲜活且香气宜人富有保健作用。

②夏茶----是指5月初至7月初采制的茶叶夏季天气炎热，茶树新的梢芽叶生长迅速，使得能溶解茶汤的水浸出物含量相对减少，特别是氨基酸等的减少使得茶汤滋味、香气多不如春茶强烈，由于带苦涩味的花青素、咖啡因、茶多酚含量比春茶多，不但使紫色芽叶增加色泽不一，而且滋味较为苦涩。 Gaosh.com 。

③秋茶----就是8月中旬以后采制的茶叶。秋季气候条件介于春夏之间，茶树经春夏二季生长、新梢芽内含物质相对，减少叶片大小不一，叶底发脆，叶色发黄，滋味和香气显得比较平和。

④冬茶----大约在10月下旬开始采制。冬茶是在秋茶采完后，气候逐渐转冷后生长的。因冬茶新梢芽生长缓慢，内含物质逐渐增加，所以滋味醇厚，香气浓烈。

3、按其生长环境来分：

①平地茶----茶芽叶较小，叶底坚薄，叶张平展，叶色黄绿欠光润。加工后的茶叶条索较细瘦，骨身轻，香气低，滋味淡。

②高山茶----由于环境适合茶树喜温、喜湿、耐阴的习性。故有高山出好茶的说法。随着海拔高度的不同，造成了高山环境的独特特点，从气温、降雨量、湿度、土壤到山上生长的树木，这些环境对茶树以及茶芽的生长都提供了得天独厚的条件。因此高山茶与平地茶相比，高山茶芽叶肥硕，颜色绿，茸毛多。加工后之茶叶，条索紧结，肥硕。白毫显露，香气浓郁且耐冲泡。

一、茶叶基本成份

1、儿茶素类:俗称茶单宁,是茶叶特有成份，具有苦、涩味及收敛性。

2、咖啡因:带有苦味，是构成茶汤滋味的重要成份。

3、矿物质:茶中含有丰富的钾、钙、镁、锰等11种矿物质。

二、茶叶基本成份之功能

1、儿茶素类:

俗称茶单宁,是茶叶特有成份，具有苦、涩味及收敛性。在茶汤中可与咖啡因结合而缓和咖啡因对人体的生理作用。具抗氧化、抗突然异变、抗肿瘤、降低血液中胆固醇及低低密度酯蛋白含量、抑制血压上升、抑制血小板凝集、抗菌、抗产物过敏等功效。

2、咖啡因:

带有苦味，是构成茶汤滋味的重要成份。红茶茶汤中，与多无酚类结合成为复合物；茶汤冷后形成乳化现象。茶中特有的儿茶素类及其氧化缩和物可使除中咖啡因的兴奋作用减缓而持续，故喝茶可使长途开车的人保持头脑清醒及较有耐力。

3、矿物质:

茶中含有丰富的钾、钙、镁、锰等11种矿物质。茶汤中阳离子含量较多而阴离子较少，属于碱性食品。可帮助体液维持碱性，保持健康。

①钾：促进血钠排除。血钠含量高，是引起高血压的原因之一，多饮茶可防止高血压。

②氟：具有防止蛀牙的功效。

③锰：具有抗氧化及防止老化之功效，增强免疫功能，并有助于钙的利用。因不溶于热水，可磨成茶粉食用。

4、维生素:

①类胡萝卜素：在人体可转换为维生素,但要和茶未一起饮咽才可补充。

②B群维生素及维生素C:为水溶性，可由饮茶中获取。

5、其他机能成份:

①黄酮醇类具增强微血管壁消除口臭功效。

②皂素抗癌、抗炎症功效。

③胺基酪酸于制茶过程中强迫茶叶进行无氧呼吸而产生，称佳叶龙茶可以防高血压。

java中Map类有什么作用，具体怎么用呢

这个我不是很清楚。但我查了一下API文档。

类 Date 表示特定的瞬间，精确到毫秒。

在 JDK 1.1 之前，类 Date 有两个其他的函数。它允许把日期解释为年、月、日、小时、分钟和秒值。它也允许格式化和分析日期字符串。不过，这些函数的 API 不易于实现国际化。从 JDK 1.1 开始，应该使用 Calendar 类实现日期和时间字段之间转换，使用 DateFormat 类来格式化和分析日期字符串。Date 中的相应方法已废弃。

尽管 Date 类打算反映协调世界时 (UTC)，但无法做到如此准确，这取决于 Java 虚拟机的主机环境。当前几乎所有操作系统都假定 1 天 = 24 × 60 × 60 = 86400 秒。但对于 UTC，大约每一两年出现一次额外的一秒，称为“闰秒”。闰秒始终作为当天的最后一秒增加，并且始终在 12 月 31 日或 6 月 30 日增加。例如，1995 年的最后一分钟是 61 秒，因为增加了闰秒。大多数计算机时钟不是特别的准确，因此不能反映闰秒的差别。

一些计算机标准是按照格林威治标准时 (GMT) 定义的，格林威治标准时和世界时 (UT) 是相等的。GMT 是标准的“民间”名称；UT 是相同标准的“科学”名称。UTC 和 UT 的区别是：UTC 是基于原子时钟的，UT 是基于天体观察的，两者在实际应用中难分轩轾。因为地球的旋转不是均匀的（它以复杂的方式减速和加速），所以 UT 始终不是均匀地流过。闰秒是根据需要引入 UTC 的，以便把 UTC 保持在 UT1 的 0.9 秒之内，UT1 是应用了某些更正的 UT 版本。还有其他的时间和日期系统；例如，基于卫星的全球定位系统 (GPS) 使用的时间刻度与 UTC 同步，但没有 针对闰秒进行调整。有关更多信息的一个有趣来源是美国海军天文台，特别是 Directorate of Time 的网址：

http://tycho.usno.navy.mil。

还有它们对 "Systems of Time" 的定义，网址为：

http://tycho.usno.navy.mil/systime.html。

在类 Date 所有可以接受或返回年、月、日期、小时、分钟和秒值的方法中，将使用下面的表示形式：

年份 y 由整数 y - 1900 表示。

月份由从 0 至 11 的整数表示；0 是一月、1 是二月等等；因此 11 是十二月。

日期（一月中的某天）按通常方式由整数 1 至 31 表示。

小时由从 0 至 23 的整数表示。因此，从午夜到 1 a.m. 的时间是 0 点，从中午到 1 p.m. 的时间是 12 点。

分钟按通常方式由 0 至 59 的整数表示。

秒由 0 至 61 的整数表示；值 60 和 61 只对闰秒发生，尽管那样，也只用在实际正确跟踪闰秒的 Java 实现中。于按当前引入闰秒的方式，两个闰秒在同一分钟内发生是极不可能的，但此规范遵循 ISO C 的日期和时间约定。

在所有情形中，针对这些目的赋予方法的参数不需要在指定的范围内；例如，可以把日期指定为 1 月 32 日，并把它解释为 2 月 1 日的相同含义。

从以下版本开始：

JDK1.0

另请参见：

DateFormat, Calendar, TimeZone, 序列化表格。

--------------------------------------------------------------------------------。

构造方法摘要

Date()

分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。

Date(int year, int month, int date) 。

已过时。 从 JDK 1.1 开始，由 Calendar.set(year + 1900, month, date) 或 GregorianCalendar(year + 1900, month, date) 取代。

Date(int year, int month, int date, int hrs, int min) 。

已过时。 从 JDK 1.1 开始，由 Calendar.set(year + 1900, month, date, hrs, min) 或 GregorianCalendar(year + 1900, month, date, hrs, min) 取代。

Date(int year, int month, int date, int hrs, int min, int sec) 。

已过时。 从 JDK 1.1 开始，由 Calendar.set(year + 1900, month, date, hrs, min, sec) 或 GregorianCalendar(year + 1900, month, date, hrs, min, sec) 取代。

Date(long date) 。

分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。

Date(String s) 。

已过时。 从 JDK 1.1 开始，由 DateFormat.parse(String s) 取代。

方法摘要

boolean after(Date when) 。

测试此日期是否在指定日期之后。

boolean before(Date when) 。

测试此日期是否在指定日期之前。

Object clone() 。

返回此对象的副本。

int compareTo(Date anotherDate) 。

比较两个日期的顺序。

boolean equals(Object obj) 。

比较两个日期的相等性。

int getDate() 。

已过时。 从 JDK 1.1 开始，由 Calendar.get(Calendar.DAY_OF_MONTH) 取代。

int getDay()

已过时。 从 JDK 1.1 开始，由 Calendar.get(Calendar.DAY_OF_WEEK) 取代。

int getHours() 。

已过时。 从 JDK 1.1 开始，由 Calendar.get(Calendar.HOUR_OF_DAY) 取代。

int getMinutes() 。

已过时。 从 JDK 1.1 开始，由 Calendar.get(Calendar.MINUTE) 取代。

int getMonth() 。

已过时。 从 JDK 1.1 开始，由 Calendar.get(Calendar.MONTH) 取代。

int getSeconds() 。

已过时。 从 JDK 1.1 开始，由 Calendar.get(Calendar.SECOND) 取代。

long getTime() 。

返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。

int getTimezoneOffset() 。

已过时。 从 JDK 1.1 开始，由 -(Calendar.get(Calendar.ZONE_OFFSET) + Calendar.get(Calendar.DST_OFFSET)) / (60 * 1000) 取代。

int getYear() 。

已过时。 从 JDK 1.1 开始，由 Calendar.get(Calendar.YEAR) - 1900 取代。

int hashCode() 。

返回此对象的哈希码值。

static long parse(String s) 。

已过时。 从 JDK 1.1 开始，由 DateFormat.parse(String s) 取代。

void setDate(int date) 。

已过时。 从 JDK 1.1 开始，由 Calendar.set(Calendar.DAY_OF_MONTH, int date) 取代。

void setHours(int hours) 。

已过时。 从 JDK 1.1 开始，由 Calendar.set(Calendar.HOUR_OF_DAY, int hours) 取代。

void setMinutes(int minutes) 。

已过时。 从 JDK 1.1 开始，由 Calendar.set(Calendar.MINUTE, int minutes) 取代。

void setMonth(int month) 。

已过时。 从 JDK 1.1 开始，由 Calendar.set(Calendar.MONTH, int month) 取代。

void setSeconds(int seconds) 。

已过时。 从 JDK 1.1 开始，由 Calendar.set(Calendar.SECOND, int seconds) 取代。

void setTime(long time) 。

设置此 Date 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。

void setYear(int year) 。

已过时。 从 JDK 1.1 开始，由 Calendar.set(Calendar.YEAR, year + 1900) 取代。

String toGMTString() 。

已过时。 从 JDK 1.1 开始，由 DateFormat.format(Date date) 取代，使用 GMT TimeZone。

String toLocaleString() 。

已过时。 从 JDK 1.1 开始，由 DateFormat.format(Date date) 取代。

String toString() 。

把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)。

static long UTC(int year, int month, int date, int hrs, int min, int sec) 。

已过时。 从 JDK 1.1 开始，由 Calendar.set(year + 1900, month, date, hrs, min, sec) 或 GregorianCalendar(year + 1900, month, date, hrs, min, sec) 取代，使用 UTC TimeZone，后跟 Calendar.getTime().getTime()。

原文地址：http://www.qianchusai.com/%E7%B1%BB%E7%9A%84%E4%BD%9C%E7%94%A8-30.html