java基础知识(适合新手入门)

Java基础知识
本文中主要分为三个部分，第一个部分介绍java的基本概念，第二部分介绍了java的基础知识，第三部分讲解了java的语法以及实现代码，适合java初学者学习。

一 Java概述
1．Java出现的背景：
1991 年Sun公司的James Gosling等人开始开发名称为Oak 的语言。

希望用于控制嵌入在有线电视交换盒、PDA等的微处理器，但却没有取得成功，后来由于互联网的发展，而由于Oak语言本身的具有安全、可移植，又可跨平台，可以解决Internet 上的大型应用问题，所以在1994年将Oak语言更名为java语言，并且于1995年正式推出，使Java成为网上最流行的编程语言。

2．Java的特点
平台无关性：一个应用程序能够运行于不同的操作系统平台，主要采用的是虚拟机技术支持平台无关性。

简单：Java 设计人员删除了C++ 中许多复杂的功能，如指针操纵和运算符重载等。

面向对象：在Java 中任何东西都是对象。

因此，重点集中在数据、应用程序中操作对象的方法以及过程上。

健壮性：Java 在编译和解释时都会检查代码。

安全性：Java 提供了用于执行程序的受控环境，以及多层次的安全控制。

分布式：Java 可用于开发能够在多个平台、操作系统和图形用户界面之间移植的应用程序。

多线程：Java 程序使用称为“多线程”的进程同时处理多项任务。

3．Java的三种运行平台
J2SE(java 2 Platform Stand Edition)，Java标准版或Java标准平台
J2EE(Java 2 Platform Enterprise Edition)，Java企业版或Java企业平台
J2ME(Java 2 Platform Micro Edition)，Java微型版或Java小型平台
4．Java的三种核心机制
①．Java 虚拟机(Java Virtual Machine)：实现java的跨平台
②．垃圾收集机制(Garbage collection)：系统自动执行，不能强制执行
③．代码安全性检测(Code Security)
5．什么是虚拟机？
虚拟机：在一台计算机上由软件或硬件模拟的计算机。

6．Java实现跨平台的原理如下图：
7．什么是JDK？
JDK是sun公司推出的java开发工具包，包括java类库、java编译器、java解释器、java 运行时环境和java命令行工具。

JDK提供java程序的编译和运行命令，但没提供程序编辑环境。

java的一些开发工具提供程序的开发环境，如：Eclipse、MyEclipse和Jbbilder等，它们都是建立在JDK的运行环境之上的。

8．什么是JRE
是Java Runtime Environment (动态)简称，也就是java的运行时环境，它提供三个主要功能：
①．加载代码：由class loader 完成；
②．校验代码：由bytecode verifier 完成；
③．执行代码：由runtime interpreter完成
9．什么是Java编译器？什么是Java解释器？
Java编译器：针对Java虚拟机产生class文件，因此是独立于平台的。

Java解释器：负责将Java虚拟机的代码在特定的平台上运行。

10．JDK的安装与设置
①．下载JDK
②．安装JDK
③．设置环境变量，设置系统变量ClassPath，输入值为C:\Program Files\Java\jdk1.6.0_18\lib。

11．编译和运行环境
①．使用javac.exe命令编译java源程序，例如：javac Hello.java，编译后会产生一个字节码文件Hello.class
②．使用java.exe命令运行字节码文件，例如：java Hello。

二 java语言基础
1．注释
//：单行注释
/*…..*/：多行注释
/**…….*/：文档注释
2．标识符
定义：Java语言中，为各种变量、方法和类等起的名字称为标识符.
Java标识符的命名规则：
①．应以字母、下划线、美元符开头，后跟字母、下划线、美元符或数字
②．Java标识符大小写敏感，长度无限制，不以数字开头（常考）
3．关键字（keywords）
定义：是由java语义定义的、具有特殊含义的单词，java中的关键字如下图：
4．分隔符（separator）
分隔符用于分开两个语法的成分。

关键字、标识符的分隔符是空格，语句的分隔符是（;）,数据的分隔符是逗号（,）等。

5．基本数据类型
①．什么是数据？
数据是描述客观事物的数字、字符以及所有能输入到计算机中并能被计算机接受的各种符号集合。

数据是计算机程序处理的对象。

②．什么是类型？
类型是具有相同逻辑意义的一组值的集合。

③．什么是数据类型？
是指一个类型和定义在这个类型上的操作的集合。

数据类型定义了数据的性质、取值范围以及对数据所能进行的运算和操作。

6．数据类型分类
Java语言的数据类型分为两大类：基本数据类型（primitive type）和引用数据类型（reference type），如下图：
7． 基本数据类型的长度
字节型byte ：占1个字节
短整型short ：占2个字节
整型int ：占4个字节
长整型short ：占8个字节
单精度浮点数float ：占4个字节
双精度浮点数double ：占8个字节
布尔类型boolean ：只有true 和false 两个取值
字符类型char ：占两个字节
8． 转义字符
\t ：制表符 \n ：换行符 \r ：回车符
\’’：双引号 \’：单引号 \\：反斜杠
9．java 命名规范
驼峰命名法：
①．类名:每个单词的首字母大写 public class UserAction{}
②．方法名:第一个单词的首字母小写,其他单词的首字母大写 public void insertUser(){} ③．变量:同方法名 private String userName;
④．常量:所有字母大写 private static final int NUMBER = 1;
10．变量
1) 定义：内存中的一块存储区域,用来存储数据的基本单元
2) 变量的声明及赋值
变量声明的格式为：变量类型 变量名
初始化变量的格式为：变量名＝值;
3) 装载的数据从类型上划分：
基本数据类型变量
int a = 1;
double d = 2; 数据类型
基本数据类型 引用数据类型
数值型
字符型(char)
布尔型(boolean ）
整数类型(byte, short, int, long)
浮点类型(float, double) 类(class)
接口(interface)
数组
byte c = 3;
引用数据类型变量
Student s = new Student();
4) java中的八种基本数据类型，从声明的位置上:
成员变量
局部变量
变量的作用域:一对{}之中，从变量声明处到“}”为变量的作用域。

11．数据类型转换
①．隐式数据类型转换(自动类型转换)
1)两种类型之间兼容
2)目标类型大于源类型(类型的提升)
例如，当byte型向int型转换时，由于int型取值范围大于byte型，就会发生自动转换byte b=3;
int x=b;//没有问题，程序把b的结果自动转换成int型了
整型和浮点型彼此都可以这样的转换。

数字类型字符串类型(String)或布尔类型（bollean ）是不兼容的。

字符类型（char ）和布尔类型也是互相不兼容的。

②．显式数据类型转换(强制类型转换)
1)两种类型之间兼容
2)目标类型小于源类型
例如：目标类型变量= （目标类型）值
例如：byte a;
int b;
a = (byte)b;
当一个表达式中有多种数据类型时,会根据类型转换的规则自动提升为最高的数据类型。

③．Java类型自动提升的规则如下：
1）所有byte、short、char型的值将被提升到int型；
2) 如果一个操作数为long型，计算结果就是long型；
3)如果一个操作数是float型，计算结果就是float型；
4)如果一个操作数是double型，计算结果就是double型。

注意：所有计算过程都是操作数先被提升，结果也被提升
12．运算符
1) 算术运算符: +，―，*，/，%，++，――。

+ （加号）、-（减号）、/（除号）、*（乘号）、%（取模）
+（字符串相加）、++x(前自增)、x++（后自增）、--x（前自减）、x--（后自减）
+（正号）、-（符号）
2)关系运算符: >，<，>=，<=，==，!=
<（小于）、>（大于）、<=（小于等于）、>=（大于等于）、==（等于）、!=（不等于）
关系运算符生成的是一个“布尔”（Boolean）结果。

它们评价的是运算对象值之间的关系。

若关系是真实的，关系表达式会生成true（真）；若关系不真实，则生成false （假）
3)布尔逻辑运算符: !，& , | , ^ , &&，||
4)赋值运算符: = 扩展赋值运算符:+=，―=，*=，/=
5)字符串连接运算符: +
6)赋值运算符
=（赋值）、+=（加赋值）、-=（减赋值）、*=（乘赋值）、/=（除赋值）、%=（取模赋值）赋值运算符的意思是“取得右边的值，把它复制到左边”。

右边的值可以是任何常数、变量或者表达式，只要能产生一个值就行。

但左边的值必须是一个明确的、已命名的变量a+=1相当于a=a+1，a/=2相当于a=a/2
注意：
“=”与“= =”的不同
+字符串相加符号能将字符串与其他的数据类型相连成一个新的字符串；
++x是在变量x参与其他运算之前先将自己加1后，再用新值参与运算，而x++是先用原来的值参与运算后再将自己加1；
如果对被模数取负模，则可以把模数的符号忽略不计，如5%-2=1；
对于/号。

整数除和小数除是有区别的：整数之间的除法时，只保留整数部分而舍弃小数部分;
13．流程控制语句
①．选择语句
if{}、if{}else{}、if{}else if{}…else{}、switch(){case 值：表达式;………}、三目运算符(condition)?value1:value2
②．循环语句
for(表达式1;表达式2;表达式3){语句}、while{布尔表达式}、do{语句;}while(布尔表达式)
14．数组
①．定义：存储同一种数据类型\长度固定的数据的数据结构
数组属引用类型，数组型数据是对象(object)，数组中的每个元素相当于该对象的成员变量，数组中的元素可以是任何数据类型，包括基本类型和引用类型。

②．数组声明
一维数组的声明方式：
type var[] 或type[] var；
例如：int a[];
int[] a1;
double b[];
Mydate []c;
注意：Java语言中声明数组时不能指定其长度(数组中元素的个数)，例如：
int a[5]; //非法
③．创建数组
Java中使用关键字new 创建数组对象，例如：int[] s; s = new int[10];
④．数组初始化
静态初始化：
在定义数组的同时就为数组元素分配空间并赋值。

int a[] = { 3, 9, 8};或者double[] ds = new double[]{1,2,3,4,5};
数组元素下标从0开始；长度为n的数组合法下标取值范围：0 ~ n-1；
数组通过.length来指定长度，，例如：a.length 指明数组a的长度(元素个数).
三 面向对象
1．对象
对象:在解空间中要研究和关注的各种事物(软件边界之内),不仅仅是具体的事物,还可以是抽象的规则,一个连接,一个计划,...instance实例
2．类
类:具有相同或者相似性质的对象的抽象,是对一组相似对象的概括
3．属性
属性:对这一类事物的内在性质的描述--成员变量--要解决的问题相关的
定义属性：访问修饰符+修饰符+数据类型+属性名
例如：private int a；
4．方法
方法:这一类事物对外界的行为
定义方法：访问修饰符+修饰符+返回类型+方法名+参数列表+异常+方法的实现5．Java内存
寄存器:在虚拟cpu内部
栈:一块连续的内存空间,基本数据类型变量和引用数据类型变量的引用
堆:不连续的内存空间,存放的是引用数据类型变量的值
静态存储区域和常量存储区:static和final修饰的变量
6．创建类的对象
声明并创建一个Person类的对象，将该对象命名为p，例：Person p1 = new Person();
步骤：
①．在栈中创建一个Person类型的引用p
②．使用new关键字在堆中开辟一块内存空间
③．将对象赋值为空
④．执行构造方法,对对象进行初始化工作
⑤．将堆中对象的地址返回给引用p,即p指向对象new Person()
7．对象中的成员变量:有初值
基本数据类型的成员变量:
byte 0
short 0
int 0
char ''
long 0
double 0.0
float 0.0
boolean false
引用数据类型的成员变量null
8．对象中的方法的形参和实参
形参:定义方法时定义的参数列表
实参:调用方法时传递的实际参数
9．java中参数的传递
java中方法参数的传递永远是值传递
对于基本数据类型:传递的是基本数据类型的值
对于引用数据类型:传递的是引用地址的值
在方法中定义的变量(局部变量)必须初始化
10．面向对象的三大特性
①．封装：隐藏对象内部的属性,对外提供公开的getters和setters方法访问属性
例如：public class Student {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
= name;
}
public static void main(String[] args){
Student s = new Student();
s.setName("zhangsan");
}
}
②．继承：子类继承父类,子类继承父类的所有属性和方法
单继承：一个父类可以有多个子类,一个子类只能有一个直接父类
③．多态：同一个名字或者符号在不同的语境下具有不同的语义解释
1) 编译时的多态--静态的多态
方法的重载overload
例如：构造方法重载
public class student{
private String name;
private int age;
public student(String name){
= name;
}
public student(String name,int age){
= name;
this.age = age;
}
}
2) 运行时的多态--动态的多态
方法的重写override 对象的造型casting
方法的重载(overload)：发生在同一个类中,有一组同名的方法,参数列表不同(类型\个数\顺序),返回类型可以相同,可以不同,抛出的异常可以相同,可以不同,访问修饰符可以相同,可以不同
方法的重写(overide)：发生在继承关系中,子类重写父类同名的方法,改变方法的实现.判断子类是否重写了父类的同名方法,首先看参数列表必须相同(类型\个数\顺序),返回类型必须相同(子类重写方法的返回类型可以是父类被重写方法的返回类型,或者是父类被重写方法返回类型的子类),访问权限不能更严格
例如：子类继承父类，并重写父类的方法。

public class People {
public void show(String xing,String ming){
System.out.printl n("bbb");
}
}
public class ChinesePeople extends People{
public void show(String xing,String ming){
System.out.println("xxxx");
}
}
11．构造方法
定义：在使用new关键字时,调用构造方法初始化对象
写法：访问修饰符+类名+参数列表+方法实现
重点：没有定义构造方法时,系统会有一个默认的无参的构造方法,该方法没有方法体,也不做任何工作,当自定义了构造方法之后,系统默认的构造方法失效
构造方法不能被继承,创建本类的对象时,会先调用父类的构造方法,再调用本类的构造方法
1) 如果在本类构造方法中,没有显式指定调用父类的某个构造方法,则会默认调用父类无参的构造方法
2) 如果在本类构造方法中,显式调用父类构造方法,使用super关键字super(参数列表),调用父类定义的带相应参数的构造方法
3) 构造方法只能在new关键字之后,或者在其他构造方法中调用,不能在普通方法中调用
注意：构造方法不能被继承,所以没有重写的概念,但是构造方法可以重载
12．this和super:
①．在构造方法中,this(参数列表)\super(参数列表):调用本类或者父类带相应参数的构造方法
②．在一般方法中,this或者super表示当前引用对象或对象的父类this.属性名/方法名super.属性名/方法名
13．= =和equals
= =：
对于基本数据类型的变量,比较的是两个变量的值
对于引用数据类型的变量,比较的是两个引用保存的对象的地址
equals方法：
在Object类中定义,比较的是两个引用的地址
在其他类中,如果重写了equals方法,则按照重写后的equals方法的规则比较两个引用是否"相等"
14．对象的造型(casting)
定义：一个对象变量的引用可以指向多种实际类型的对象(形式类型和实际类型的不同) Person p = new Student();(Student类是Person的子类)
1.向上转型(上溯造型):父类类型的引用指向子类类型的实例
1)对于重写的方法,运行时调用的是子类重写的方法
2)对于自有的方法,不可见
2.向下转型(下溯造型)--强制类型转换
1)需要子类类型与引用对象的类型一致(存在继承关系)
15．static用法
①．修饰方法:static修饰的方法叫做静态方法,无需创建对象,直接类名.方法名(参数列表)
1) 静态方法只能访问静态方法或者属性
2) 静态方法中不能使用this或者super
3) 非静态方法可以访问静态属性或者方法
②．修饰属性:static修饰的属性,叫做静态属性/变量(类的属性\类的变量),无需创建对象,直接类名.属性名访问该静态变量
静态变量和静态方法不是某个对象所有,而是属于整个类的,(通过任意对象访问静态变量和静态方法都是访问的同一个类的静态变量和静态方法)
③．静态代码块
static{} 类加载的时候执行一次,不能访问非静态属性和方法,不能使用this或者super
④．修饰类:静态内部类
16．final用法
final修饰的类不能被继承
final修饰的方法不能被重写
final修饰的变量--常量,只能在定义时或者构造方法中赋值一次
17．static和final的比较
static int A 任意地方赋值一个类一个A
final int A 定义或者构造方法中赋值每个对象的A
static和final共同修饰的变量--静态常量,类的变量,一次赋值,只能在定义或者静态代码块中赋值
final修饰局部变量或者形参:常量(基本数据类型的形参,值不能变;引用数据类型的形参,地址的值不能变)
18．abstract
用abstract修饰的类叫抽象类,抽象类不能被实例化abstract和final不能同时修饰类或者方法
用abstract修饰的方法叫做抽象方法,抽象方法没有方法体,必须由继承该抽象类的子类来实现,
抽象类中,可以有非抽象方法
抽象类中,可以没有抽象方法
有抽象方法的类必为抽象类
抽象类可以继承抽象类
19．接口（interface）
定义：在一定"粒度"上反映"同类事物"的抽象表示，一种特殊的抽象类
接口中的方法,全部是抽象方法,public
接口中的属性,全部是public static/static final
20．StringBuffer和StringBulider的区别
StringBuffer:线程安全,执行效率低于StringBuilder
StringBuilder:非线程安全
21．重写hashCode方法,使得equals和hashCode方法遵循如下约定:
①．equals方法为true的两个对象,hashCode()一定相等
②．equals方法为false的两个对象,hashCode()不一定不相等
③．hashCode()不等,则equals()一定为false
④．hashCode()相等,则equals可能相等,可能不等
22．8种基本数据类型的封装类
byte -- Byte short -- Short char -- Charactor
int -- Integer long -- Long float -- Float
double -- Double boolean-- Boolean
注意：JDK1.5之后新特性:自动装拆包,java编译器在编译时,对于基本数据类型-->封装类型的转换规定:对于boolean,byte,相同的值放在同一个封装对象中,char<=127相同的值放在同一个封装对象中,short和int在-128到127之间,放在同一个封装对象中
23．类型间的转换
封装类-->基本数据类型xxxValue()
基本数据类型-->封装类构造方法/static valueOf(int x)
字符串-->基本数据类型static parseXXX(String str)
基本数据类型-->字符串""+1 / 基本数据类型-->封装类-->toString()
24．异常
例：
try{ --监视可能出现异常的代码段
int a = 1;
int b = 0;
int c = a/b;
}catch(ArithmeticException e){ --捕获发生的异常
e.printStackTrace(); --对异常做处理
}
异常的分类：
①．Error
②．Exception
1) 普通异常:需要显式的捕获
2) 运行时异常(RuntimeException的子类):不需要显式的捕获
多重catch块，catch的异常类型,从小到大,从子类到父类
finally:不管是否产生异常,finally中的代码一定会执行
25．throws和throw
Throws：声明方法可能会跑出某个异常,调用方法的时候要么用try\catch抓异常,要么继续向上抛异常
Throw：显式的抛出一个异常throw new Exception(),如果抛出的是非运行时异常,则需要throws声明,或者显式的捕获
26．自定义异常
在编写程序时，有时候系统提供的异常不能满足我们的需要，所以要自己定义一些异常，称为自定义异常，它继承Exception。

三java程序代码示例：
这部分主要讲述了一些java语法以及相应的实现代码。

1.//最基本的JAVA程序必须有一个类，在这里是MainTest
class MainTest
{
//在JA V A中，程序的入口也为main函数，函数前的限制符顺序必须为public static void,参数必须为String类型的数组
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
2.java源文件的命名规则
在同一个JA V A文件中可以定义多个类，但是只有一个类能定义为public
而且如果一个类被定义为public，这个文件的文件名必须和该public类
的名字相同。

class A
{
int a;
};
class B
{
int b;
};
public class C
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
3.基本数据类型的操作
class code01
{
public static void main(String[] args)
{
//JA V A的数据类型。

请注意大小写
//一个字节的整型
byte e=3;
System.out.println(e);
//两个字节的整型
short h=4;
System.out.println(h);
//四个字节的整型
int f=4;
System.out.println(f);
//八个字节的整型
long g=5;
System.out.println(g);
//4个字节的浮点数
float a=11.3f;
System.out.println(a);
//8个字节的浮点数（更加精确）
double b=12.3d;
System.out.println(b);
//两个字节的单个字符。

注意定义字符的时候不能用双引号，只能用单引号
char c='s';
String ss="xiongyong";
System.out.println(c);
//bool变量，用于判断真假。

注意：true和false不能大写。

boolean d=true;
System.out.println(d);
//final关键字为“常量”，意思是不能再被修改。

相当于C++中的const
final int x=1;
//以下这行将被报错，因为x被定义为final，不能被修改。

x=x+1;
}
}
4.自动数据类型转换------强制类型转换
不同的数据类型可以进行混合运算。

在运算过程中，不同数据类型必须首先转换为相同的数据类型后才能进行运算。

各种数据的转换原则是从低级向高级转换。

具体如下：
char->byte->short->int->long->float->double
JA V A允许把高级类型转换为低级类型，我们通过强制类型转换实现。

class Test1
{
void f1()//自动类型转换
{
int nO=2;
float fO=2.25f;
//以下这行不能被正确编译，因为算出来的结果不可能是整数
//int iResult=nO*fO;
//正确
float fResult=nO*fO;
System.out.println("混合运算结果为:"+fResult);
}
void f2()//强制类型转换
{
int nO=2;
float fO=2.25f;
float iResult=(int)(5.5*fO);
System.out.println("强制类型转换结果为:"+iResult);
}
public static void main(String[] args)
{
code03 c3=new code03();
c3.f1();
c3.f2();
}
}
5.运算符和类型转换
+运算符和类型转换
+对于数字来说是求和运算。

两个short类型数据相加，结果将被升级为int类型。

+对于字符串来说连接两个字符串的运算
class Test2
{
void f_add_string()
{
String a="hello ";
String b="world";
//请观察输出结果，体会字符串+字符串的功能
System.out.println(" a+b= "+a+b);
}
void f_add_number()
{
short x=1,y=2,z;
int p;
//错误代码。

两个short类型数据相加，结果将被升级为int类型。

而z却还是short类型z=x+y;
//正确代码
z=(short)(x+y);
System.out.println(" 1 + 2 = " + z);
p= x+y ;
System.out.println(" 1 + 2 = " + p);
}
public static void main(String[] args)
{
code04 c4=new code04();
c4.f_add_string();
c4.f_add_number();
}
}
6.JA V A允许在程序中调整数组中元素的个数
*********************************************************************/ class Test3
{
public static void main(String[] args)
{
int myArray[]=new int[6];
int i;
for (i=0;i<myArray.length ;i++ )
{
myArray[i]=i;
System.out.println(myArray[i]);
}
//重新定义数组，注意，myArry以前的内容被重置了
myArray=new int[10];
for (i=0; i<myArray.length;i++ )
{
//重新定义数组
//myArray[i]=i*10;
System.out.println(myArray[i]);
}
}
}
7.数组
下列是一个常见的“冒泡排序”的程序，用于把几个数按大小进行排序
**************************************************************************/ class Test4
{
public static void main(String[] args)
{
//定义一个包含n个数的数组
int nArray[]={11,-5,100,56,321};
//JA V A是纯面向对象的语言，对于任何一个数组元素，JA V A都把它看做一个数组类型的对象，
//length是这个类的一个成员变量，它的值等于该对象中数组元素的个数。

//所以我们能通过nArray.length获得这个数组nArray里面包含元素的个数。

//对于本题，它等于5。

int size=nArray.length-1;
for (int j=0;j<size;j++)
{
for (int i=0;i<size ;i++ )
{
if (nArray[i]>nArray[i+1])
{
int tmp=nArray[i];
nArray[i]=nArray[i+1];
nArray[i+1]=tmp;
}
}
}
for (int i=0;i<nArray.length ;i++ )
{
System.out.println(nArray[i]+" ");
}
}
}
8.判断素数
class Test5
{
//判断一个数x是不是素数
public boolean is_sushu(int x)
{
for (int i=2;i<x ;i++ )
{
if (x%i==0)
{
return false;
}
}
return true;
}
//显示1到x之间的所有素数
public void disp(int x)
{
for (int i=1;i<=x ;i++ )
{
if (is_sushu(i))
{
System.out.println(i);
}
}
}
//程序入口
public static void main(String[] args)
{
code12 c12=new code12();
c12.disp(1000);
}
}
9.参数传递
* ①使用简单数据类型做为参数时的函数传值方式
* 当参数为简单数据类型时，参数传值使用复制传值方式，也就是说作为参数传进函数的值只是传进来值的一个副本
class Test6
{
public static void main(String[] args)
{
System.out.println("Hello World!");
int j=10;
//本例中calculate函数传递的是简单数据类型参数j，所以使用复制传递方式，函数中并
//没有改变原来j的内容
calculate(j);
System.out.println("======================================");
System.out.println("执行完calculate函数后j的值为："+j);
}
static void calculate(int j)
{
for (int i=0;i<10 ;i++ )
{
j++;
}
System.out.println("calculate函数中j的值为："+j);
}
}
* ②使用复杂数据类型做为参数时的函数传值方式
*
* 当参数为复杂数据类型时，参数传值使用引用传值方式，也就是说作为参数传进函数的值只是传
* 进来值的一个别名，直接效果就是函数中对参数做的修改直接就影响到原始的值
*
*/
class Test7
{
public static void main(String[] args)
{
String a="hello";
System.out.println("初始阶段数组a的值为：" + a);
calculate(a);
System.out.println("调用calculate函数后，数组a的值为：" + a);
System.out.println("由此可知，在本函数中，参数是作为复杂变量的别名传进函数的，证据就是在函数中确实改变了函数外部变量a的值");
}
static void calculate(String j)
{
j="world";
System.out.println("calculate函数中参数数组j的值为："+j);
}
}
10．函数的返回值
*
* return语句的作用是把一个确定的值返回给调用它的语句，这个值可以是* 简单变量，也可以是对象。

如果返回值是对象，则返回的实际上是对象的* 地址。

这个情况和参数传递相同
*/
Class Test8
{
//求x*x+2(y+1)+3的函数
static float mathF1(float x,float y)
{
float z=x*x+2*++y+3;
//我们可以这样写返回值
return z;
}
static float mathF2(float x,float y)
{
//我们也可以这样写返回值（直接返回一个运算表达式的结果）
return x*x+2*++y+3;
}
public static void main(String[] args)
{
//System.out.println(a);
//我们可以这样获得返回值
float z=mathF2(4f,5f);
System.out.println("运算结果="+z);
//我们也可以这样获得返回值
System.out.println("运算结果="+mathF1(4f,5f));
}
}
11.函数的嵌套
*
* 函数自己调用自己叫做嵌套
*/
class Test9
{
static int i=0;
//这是一种不好的嵌套，在函数体中无条件的调用了自己。

导致的结果就是无限的循环static void cout_line()
{
System.out.println("=============================");
cout_line();
}
//一种安全的嵌套，有条件的调用自己，不会导致死循环
static void cout_line2()
{
System.out.println("=============================");
i++;
if (i<10)
{
cout_line2();
}
}
public static void main(String[] args)
{
//请注释掉这个函数，因为它将导致死循环，函数永远不结束
cout_line();
cout_line2();
}
}。