java语言入门Word文件下载.docx
《java语言入门Word文件下载.docx》由会员分享，可在线阅读，更多相关《java语言入门Word文件下载.docx（49页珍藏版）》请在冰点文库上搜索。
return age;
public void setAge（Integer age） {
}
Java类的组成：
介绍类的三个组成部分。
一、数据成员：
数据成员是类的属性，声明该类的对象所具备的属性。
声明数据成员往往需要声明以下几项：
1.权限修饰符（Java中权限修饰符有4种，在以后文章中会介绍）：
本例中使用的是私有权限private。
在大多数情况下，都建议数据成员使用私有权限。
2.数据类型：
数据成员必须指明其数据类型，本类中使用的类型有String和Integer。
Java中的数据类型分两种，基本类型和引用类型。
（在以后文章中会详细介绍）。
3.数据成员标志符：
即数据成员的名字。
名字要遵守Java的命名规范，最好采用名词性质的单词命名，可以由数字、字母、$、_组成，但是首字母不能是数字。
4.初值：
数据成员可以赋初值，也可不赋初值。
如果不赋，则会有默认值（根据数据类型不同而不同）。
二、构造方法：
构造方法是为了创建对象的，反过来亦成立，创建对象必须使用构造方法。
比如要创建Customer类对象，必须使用new关键字调用Customer类的某一个构造方法。
在该例子中，有3个构造方法。
如：
Customercust=newCustomer（“Gloria”,”abc”）;
三、方法成员：
方法成员是该类对象所能进行的操作。
往往需要声明一下几项。
1.权限访问修饰符：
与数据成员的修饰符概念相同，该类中的方法使用公有权限public。
2.返回值类型：
方法成员必须指明返回值类型，如果该方法没有返回值，则使用void。
3.方法成员标志符：
即方法的名字。
规则与数据成员标志符相同。
建议方法成员采用动词性质单词命名。
Java类的包
Java应用是由若干个类组成的。
但是从逻辑上考虑，这些类解决的问题都是不同的。
比如某些类解决了数据库访问问题，某些类解决了安全控制问题…就如同我们计算机硬盘上的文档，我们不会把它们都杂乱无章的放在某个硬盘的根目录下，而是按照个人习惯进行分类，放在不同的文件夹下。
Java应用中的类也一样，也应该按照逻辑进行分类，放在不同的目录下，这就是包的概念。
虽然Java语法本身，不要求必须给某个类显式指明包名，可以使用默认包。
但是，在开发Java项目的过程中，任何类都应该有包。
对一个类指定包名，使用如下语法即可：
package com.csst.db;
public class CustomerDAO {
}
只要指定了package，编译CustomerDAO后，class文件就将存在于com/csst/db文件夹下。
从物理上讲，包其实就是文件夹。
但是需要注意的是：
只要一个类指定了包名，那么包名就是名字空间的一部分，也就是说，CustomerDAO.class的名字其实是com.csst.db.CustomerDAO，而不是CustomerDAO。
正因为如此，使用该类，就得指定完整的名字，如：
package com.csst.service;
class CustomerService {
private com.csst.db.CustomerDAO dao;
注：
如果CustomerService的包名与CustomerDAO包名相同，那么不需要指定包名。
而在实际应用中，没有人愿意写这样冗长的名字，一般都是使用import关键字，把不同包的类进行导入。
import com.csst.db.CustomerDAO;
public class CustomerService {
private CustomerDAO dao;
如果需要同时使用com.csst.db包中很多类，可以使用importcom.csst.db.*语句导入多个类。
总之，包就是从逻辑上将类进行分离。
当Java类有了Java类中的包后，不仅能很好的避免重名问题（包名就是类名的一部分，保证包名不同较容易），而且还能很好得使用Java语言的修饰符，进行权限控制。
Java语言的访问权限修饰符
上篇文章中，提到了Java类需要打包，打包后可以进行访问权限控制。
本文中，将对Java语言中的访问权限修饰符，进行简单介绍。
一个Java应用有很多类，但是有些类，并不希望被其他类使用。
每个类中都有数据成员和方法成员，但是并不是每个数据和方法，都允许在其他类中调用。
如何能做到访问控制呢？
就需要使用访问权限修饰符。
Java语言中的访问权限修饰符有4种，但是仅有3个关键字，因为不写访问权限，在Java中被称为默认权限，或同包权限，本文中以（default）代替。
下面按照权限从小到大的顺序对4中访问权限分别介绍。
1．私有权限private
private可以修饰数据成员，构造方法，方法成员，不能修饰类（此处指外部类，不考虑内部类）。
被private修饰的成员，只能在定义它们的类中使用，在其他类中不能调用。
2．默认权限（default）
类，数据成员，构造方法，方法成员，都能够使用默认权限，即不写任何关键字。
默认权限即同包权限，同包权限的元素只能在定义它们的类中，以及同包的类中被调用。
3．受保护权限protected
protected可以修饰数据成员，构造方法，方法成员，不能修饰类（此处指外部类，不考虑内部类）。
被protected修饰的成员，能在定义它们的类中，同包的类中被调用。
如果有不同包的类想调用它们，那么这个类必须是定义它们的类的子类。
4．公共权限public
public可以修饰类，数据成员，构造方法，方法成员。
被public修饰的成员，可以在任何一个类中被调用，不管同包或不同包，是权限最大的一个修饰符。
有关Java语言的修饰符，需要注意的问题有如下几个：
1．并不是每个修饰符都可以修饰类（指外部类），只有public和default可以。
2．所有修饰符都可以修饰数据成员，方法成员，构造方法。
3．为了代码安全起见，修饰符不要尽量使用权限大的，而是适用即可。
比如，数据成员，如果没有特殊需要，尽可能用private。
4．修饰符修饰的是“被访问”的权限。
Java语言中的数据类型及String类
Java类中的主要组成部分就是数据成员和方法成员。
而数据成员的声明必须指定其数据类型，方法成员的声明也必须指定其返回值类型，如果方法有形式参数，也必须指定其参数类型。
因此，对于初学者来说，了解Java语言的数据类型是非常必要的。
Java语言中的数据类型可以分为两大类，即基本数据类型（也有人称为原始类型）和引用类型（也有人称类类型，对象类型等）。
Java语言是面向对象的语言，大多数数据都是引用类型，基本类型主要为了进行数学运算。
下面对这两种类型分别进行介绍。
1.基本数据类型：
Java中的基本数据类型分4大类
整型：
byte,short,int,long
浮点型：
float,double
字符型：
char
逻辑型（也称布尔型）：
boolean（true、false）
值得一题的是，Java中的基本数据类型的数据长度是跨平台的，不会因为运行的平台不同而不同。
另外需要注意的是，整型默认以32位的int存储，浮点型默认以64位的double存储。
如下面例子：
package com.csst.test;
public class TestType {
/**
* @param args
*/
public static void main（String[] args） {
float f=1.0;
//会有编译错误
}
出现错误的一行，主要就是因为数据类型转换引起。
1.0是浮点型，默认以64位的double存储，而程序中将1.0声明位32位的float，就会出现编译错误。
基本原则是高精度的数不能直接赋值给低精度的数。
修改如下：
floatf=（float）1.0;
称为强制类型转换。
2.引用类型：
可以说，除了基本数据类型以外的数据，都是引用类型。
也可以说，引用类型就是对象，或者对象都是引用类型。
很多人会有一个疑问，字符串算什么类型？
让我们看看，在基本类型的8个类别中，没有字符串，那么可以肯定的说，字符串是引用类型。
但是接下来的疑问就是，引用类型都是对象，对象不都是用new创建出来的么？
为什么我们常常看到如下语句：
Strings=”HelloWorld”;
其实，在所有的类中，包括我们自己创建的类，以及API中已有的类，只有String这个类比较特殊，可以直接使用=进行赋值，不用使用new关键字。
但是String既然是对象，也可使用new创建，如：
Strings=newString（“HelloWorld”）;
那么这两种声明方式，有何不同?
如果使用new关键字创建，那么每次创建，都是在内存空间初始化一个新的字符串对象，而如果使用＝创建，并不会每次都初始化一个新的。
而是会看一下实例池中是否有字符序列相同的字符串，如果有，就将引用指向该空间，如果没有，才初始化，如下：
String s1=”abc”;
String s2=”abc”;
String s3=new String（“abc”）;
String s4=new String（“abc”）;
其中假设s1赋值时，在实例池中没有找到abc字符串，那么s1就被初始化到内存中。
但是创建s2时，由于已经有了一个用＝号创建的abc了，将不会创建新的对象，而是将s2也指向跟s1相同的空间，共享s1的abc。
而s3,s4由于是使用new创建的，所以都会新创建对象，在内存中初始化新的abc字符串。
String类有这样的特性，源于String类另一个特征：
String对象是不可变的。
也就是说，不管通过哪个方式初始化到内存中的字符串，都是不能被修改的。
Strings=”abc”;
s=”def”;
当s被重新赋值时，并不是修改了abc，而是会新开辟内存空间，初始化新的字符串def。
Java语言中的构造方法
通过以上4篇文章的介绍，已经了解了Java类的组成，Java语言中的包，权限访问修饰符，数据类型这些基本概念。
Java是面向对象的语言，运行期，就是若干个对象彼此交互，彼此发送消息的过程。
对于初学者来说，首先就要了解有了Java类，如何创建对象。
如果有一个名字为Customer的类，那么要创建该类的对象，必须使用new关键字调用构造方法。
比如，Customer类会有以下3个构造方法：
publicCustomer（）{
publicCustomer（Stringcustname,Stringpwd）{
this.custname=custname;
this.pwd=pwd;
publicCustomer（Stringcustname,Stringpwd,Integerage）{
this.age=age;
根据这个例子，总结构造方法的特征：
1．构造方法的名字必须与类名同名，大小写也必须完全一致。
2．构造方法可以使用四种权限修饰符修饰。
3．构造方法没有返回值类型，注意，连void也没有。
4．一个类的构造方法，可以有多个，主要靠参数区别。
5．构造方法的方法体可以写任何符合Java语法的语句，但是，构造方法大多数时候都是用来初始化数据成员的。
使用构造方法，有如下语法：
Customercust=new构造方法；
对于构造方法，还有一个问题需要特别注意，就是默认构造方法问题。
如果一个类没有显式声明构造方法，那么会有一个默认的构造方法，这个构造方法没有参数，方法体也为空，如：
但是，只要类显示地声明了构造方法，那么这个无参的构造方法就不会默认存在了，如果需要使用，也必须显式地声明。
有关构造方法，在继承时，也有一些细节需要注意，会在以后博文中介绍。
Java语言中的static修饰符
在Java类中，我们常常会看到static关键字，往往被称为静态的。
Static修饰符可以用来修饰数据成员，方法成员，但是不能修饰类（此处指外部类），不能修饰构造方法。
public class User {
private String name;
private static int count;
public String getName（） {
return name;
}
public void setName（String name） {
this.name = name;
public static int getCount（） {
return count;
public static void main（String[] args）{
User user1=new User（）;
User user2=new User（）;
user1.setName（"
Rose"
）;
user2.setName（"
Kate"
user1.count=10;
user2.count=20;
System.out.println（"
user1.name:
"
+user1.getName（）+"
user2.name:
+user2.getName（））;
user1.count:
+User.getCount（）+"
user2.count:
+user2.count）;
该程序运行结果为：
Rose user2.name:
Kate
20 user2.count:
20
我们可以发现，user1和user2的name属性是不同的，分别为该对象调用setName所指定的，而虽然user1和user2分别对count属性指定了不同的值，但是最终输出的count值却均为20。
原因就是count被static修饰，而name没有使用count修饰。
被static修饰符修饰的数据成员或方法成员被称为静态成员，或者类成员，没有被static修饰的，被称为实例成员。
static成员只被初始化一次，所有的对象共享，因此count会输出两个20。
实例成员只有当初始化对象的时候才初始化，每次创建对象，都会被初始化一次。
name在user1和user2被创建时，初始化了2次，因此最终输出的是Rose和Kate。
另外，static成员，由于是类共享的，所以不仅可以使用对象调用，也可以使用类名调用。
在static方法中，不能够直接使用非静态的成员，如果使用，必须初始化对象，调用。
如过在上面示例的User.java中有如下代码，会发生编译错误。
public static void test（）{
setName（"
test"
可以修改如下：
User user=new User（）;
user.setName（"
千万不要盲目的把成员声明为static，一定要理解static成员的特点，否则会造成虽然语法正确，但是逻辑错误的后果。
Java类中的各种数据
本文是Java教程之Java类中的各种数据部分。
按照数据声明的位置，Java类可以分为两类，声明位置的不同，作用域就有所不同。
1.数据成员：
在类体中声明的数据，称为数据成员。
2.局部变量：
在方法中声明的数据，称为局部变量，也称为本地变量，方法变量，自动变量。
局部变量只能在该方法中使用。
如下例所示：
public class TestData {
//1.数据成员
private int x;
private int y;
public void test（int y）{
//2.局部变量
int z;
this.y=y;
System.out.println（x）;
//输出0
System.out.println（z）;
//编译错误
接下来，对数据成员以及局部变量的区别进行总结。
1.访问权限修饰符：
访问权限修饰符可以修饰数据成员，但是不能修饰局部变量。
2.static修饰符：
static修饰符可以修饰数据成员，但是不能修饰局部变量。
3.数据类型：
数据成员和局部变量都可以使用任何数据类型。
数据成员可以不赋初值，有默认值，如整型默认为0，浮点型默认为0.0,字符型默认为/u0000,布尔型默认为false,所有引用类型默认为false。
而局部变量使用前一定赋初值，否则会有编译错误。
5.作用域：
数据成员可以在整个类中使用，只要权限允许，也可以在其他类中通过对象或者类名（static成员）调用。
而局部变量只能在当前方法中使用。
6.生命周期：
数据成员都随着类的加载（static）或者对象的创建（非static）而被初始化，随着对象的销毁或者类的销毁而销毁。
而局部变量都是在调用该方法时临时被初始化，而方法运行结束即刻被回收。
7.如果遇到方法参数恰好与数据成员同名的情况，使用this来区别，this表示当前的引用，点取的就是数据成员。
初学者只要了解以上几点，相信再看Java类的各种数据，就会清楚得多了。
Java语言中的运算符与流程控制
不论使用何种语言，最终都是为了实现业务逻辑。
在面向对象的编程语言中，业务逻辑都在方法中实现。
因此，对于初学者来说，了解完成Java类方法体的基本知识点是非常必要的。
本文中，将介绍编写方法体必须了解的两个方面：
运算符，流程控制。
Java中的运算符根据其功能，可以分成4类。
首先需要注意的是，Java中的运算符是不能重载的。
下面分别对4类运算符进行介绍。
1、算术运算符：
+,-,*,/,%,++,--
算术运算符是对基本数据类型进行运算的操作符，其中容易混淆的是/表示除，而%表示取余。
另外需要注意的是++,--两个自加自减运算符的区别，如下程序。
packagecom.csst.test;
publicclassTest1{
/**
*@paramargs
*/
publicstaticvoidmain（String[]args）{
//TODOAuto-generatedmethodstub
inti=0;
System.out.println（i++）;
System.out.println（++i）;
intj=0;
System.out.println（j--）;
System.out.println（--j）;
}
++,--在变量后，是先取变量没有运算前的值，当作表达式的返回值，然后进行运算。
而++,--如果在变量前，是先对变量进行运算，然后将运算结果作为表达式的返回值。
需要注意的是，不管在前还是在后，对于参与运算的变量本身，都是进行了一次加1或者减1的操作，没有区别，有区别的是返回值的值。
算术运算符都是针对基本数据类型进行运算的，只有＋除外，可以使用＋连接两个字符串。
Strings=”Hello”+”World”；
//String的值是HelloWorld
2、位运算符：
&
|,^,～,<
<
>
>
位运算符是针对二进制的数进行运算的操作符。
与操作&
的运算规则是两个都是1才是1，或操作|的规则是一个是1就是1，异或^的规则是不同的是1，相同的为0。
取反操作~是1变0，0变1。
：
左移运算符，规则为，抛掉相应位数的高位，在对应的空位补0。
如：
01101001<
2=10100100
有符号右移，规则为，抛掉相应位数的低位，如果移位前，最高一位是0，则在对应的高位都补0，如果移位前，最高一位是1，则在对应的高位都补1。
01101001>
2=00011010
11101001>
2=1101
升级会员 