java复习，
java复习，
一.Java概述
1.1 Java历史、发展、现状
◆历史:
1990年:SUN公司启动green计划
1992年: 创建Oak(橡树)语言—》Java
1994年: JamesGosling参加硅谷大会，通过java 编写的浏览器WebRunner演示了java 的功能，并震惊世界
1995年: sun发布JDK第一个版本 JDK1.0 目前已经到了JDK8
2009年:Oracle收购了SUN公司。
◆现状
Java技术已经成为世界上最卓越的企业应用和移动应用开发平台之一
◆发展
安卓、物联网、云计算、大数据
1.2 Java的特点
Java的白皮书中说:“Java是一种
简单的、
解释的、
健壮的、
安全的、
高效的、
多线程的
分布式的、
可移植的、
动态的语言、
结构中立的、
面向对象的、
1.3 Java运行机制
Java语言是一种特殊的高级语言，他既具有解释型语言的特点，也有编译型语言的特点，因此Java程序需要经过先编译、后解释执行两步。(偏重于解释型语言)
编译型语言:使用专门的编译器，针对特点平台(操作系统)将某种高级语言一次性编译成该平台可以执行的机器码。 C、C++
解释型语言:使用专门的解释器，对源程序逐行解释成特定平台的机器码并立即执行的语言。
Ruby，Python
JDK、JRE、JVM概念：
▼JDK（JavaDevelopment Kit Java标准开发包）
JDK是美国SUN公司提供的一套用于开发java应用程序的开发包，他提供了编译和运行java程序所需的各种工具和资源。它包含:JRE，Java工具，Java基础类库。
------- JRE（Java Runtime Environment）Java运行时环境
|
JDK----------|------ java的工具: javac.exe（java编译器）
| java.exe(java解释执行器)
|
-------java的类库:(3600多个) 常用的150多个
▼JRE(JavaRuntime Environment Java运行时环境)
JRE是Java程序运行的必须条件，如果我们只想运行java程序，可以只用安装JRE，而不需要安装JDK。但是如果我们要开发Java程序，必须安装JDK。
▼JVM(Java Virtual Machine Java虚拟机)
JVM是负责解释执行字节码文件。相同的字节码文件要想在不同的平台(操作系统)上运行是不可能的，只有通过中间的转换器才可以实现，JVM就是充当了这个转换器。Java是通过JVM实现跨平台的，跨平台也是java最大的优势之一。
JRE和JVM的联系与区别:
JRE包含JVM。JVM是运行java程序的核心虚拟机，他负责解释执行字节码文件，但是java程序运行不仅仅需要jvm，还需要其他的资源,例如:类，类加载器，字节码校验器….. JRE处理包含JVM外，还拥有Java程序运行所需的所有资源。
1.4 JDK安装与配置
安装:
下载JDK直接安装即可
配置:
安装完成JDK后， 我的电脑—》右键—》属性—》高级系统设置—》高级—》环境变量—》下面 系统变量 选择path—》变量中后面追加 ; C:\Program Files\Java\jdk1.7.0_45\bin –》确定即可。
配置完成后，打开DOS窗口 输入 javac 、java命令测试
1.5第一个java程序
◆第一步:编写源程序
新建记事本，重命名为Hello.java 编写如下代码
public classHello{
public static void main(String[] args){
System.out.println("HelloWorld!我的第一个java程序!");
}
}
◆第二步:javac命令编译
进入dos窗口，用cd命令切换路径到Hello.java所在位置。使用javac编译
如果代码没有错误，编译成功，生成Hello.class字节码文件
如果代码有错误，会提示错误，我们需要修改错误再重新编译。
◆第三步:java解释执行
接着上面一步，编译生成字节码文件后
1.6 Java两大机制
³ Java两大核心机制 JVM、GC
² Java虚拟机（Java Virtual Machine）
± Java虚拟机机制屏蔽了底层运行平台的差别，实现了“一次编译，到处运行”
² 垃圾收集机制（Garbage Collection）
± 在 C/C++ 等语言中，由程序员负责回收无用内存。
± Java 不需要程序员负责回收无用的内存：它提供一种系统级线程跟踪存储空间的分配情况。并在JVM空闲时，检查并释放那些可被释放的存储空间。
± 垃圾回收在 Java 程序运行过程中自动进行，程序员无法精确控制和干预。
一、 Java中的注释和javadoc命令
注释:用来说明某段代码的作用，某个类的用途，某个方法的功能…….
Java中注释分为三类:单行注释，多行注释，文本注释。
单行注释: //注释内容
多行注释: /*
注释内容
……
注释内容
*/
文档注释: /**
*注释内容
* ……
*注释内容
*/
写完文档注释后可以生产API。API可以帮助用户学习和理解改程序。
进入dos窗口，使用cd命令进入Hello.java所在路径，输入javadoc Hello.java
二、 Java的分隔符
Java语言中(;) 、({})、 ([])、 (())、 (,)、 (.)、 ( )都具有特殊分隔作用，因此他们统称为分隔符。
▼分号 ;
用作语句分隔。Java中语句分隔不是使用回车，而是使用分号。每个java必须以;结尾。Java代码中允许一行写多条Java语句，但是每条Java语句中必须以;分隔开来。
▼花括号 {}
定义一个代码块。
注意:有一个”{”必须有一个”}”与之对应
▼方括号 []
用来访问数组元素。
▼圆括号 ()
定义方法时使用();
表达式中某一部分是一个整体，保证表达式的优先级 (10+3)/2
强制类型转换
▼逗号 ,
变量声明时分隔多个变量 int a,b,c;
方法定义时分隔多个参数 int max(int a,int b,int c){}
数组中变量值的风格 int[] a = {1,2,3,4,5};
▼圆点 .
类/对象和定义的成员之间的分隔符，表明调用某个类或对象的某个指定成员。eg： System.out.println(); p.age
▼空格
分隔一条语句的不同部分。空格几乎可以出现在代码的任何部分，也可以出现任意多个空格。
三、Java标示符的定义原则和关键字
▼标示符:所谓标示符就是给程序中类、方法、变量命令的符号。
public class Demo{
public static void main(String[] args){
inta = 10;
System.out.println(a);
}
}
上面代码中 Demo类名、main方法名、a变量名
▼标示符命名规则:
Java语言中标示符必须以字母、下划线(_)、美元符号($)开头，后面可以跟上任意数目的字母、数字、下划线(_)、美元符号($)。此处的字母不仅仅是26个英文字母，还可以是中文字符、日文字符…….
注意:标示符不能包括空格，不能使用java的关键字和保留字和直接量，标示符的长度不受限制。
由于Java采用的Unicode编码，因此Java的标示符可以使用Unicode能够表示的任意字符。Java语言严格区分大小写，因此Abc和abc是不用的标示符。
▼Java关键字、保留字
关键字 48个
Java语言中有一些具有特殊用途的单词被称为关键字(KeyWord) eg: if for while…..（见课本P47页）
保留字 2个
Java共有48个关键字，除了这48个关键字外还有goto、const这两个保留字。(Java现在还没有使用它们作为关键字，但是将来的版本中可能使用它们做为关键字)
直接量 3个
Java中还有三个直接量也不能作为标示符: true false null
注意:java中关键字、保留字、直接量都是小写，If,For都可以用来作为标示符。(Java严格区分大小写)
四、基本数据类型
Java语言是强类型，每一个表达式或者变量都有一个在编译时就确定好了的类型，所有变量需要先声明后使用。
Java中数据类型包括 基本数据类型 和 引用数据类型(复杂数据类型)两大类
8种 数组、类、接口
★基本数据类型(4类8种)
▼1.整数类型
|
类型 |
存储需求 |
取值范围 |
|
byte |
1字节 |
–128 到 127 |
|
short |
2字节 |
–32,768 到 32,767 |
|
int |
4字节 |
–2,147,483,648到 2,147,483, 647 (刚刚超过20亿) |
|
long |
8字节 |
–9,223,372,036,854,775,808 到 9,223,372,036,854,775,807 |
整型:表示没有小数部分的数值，可以是负数。
▶▶ 一般情况下面int最常用，因此Java中一个整型常量默认为int。长整型后需要添加一个后缀L或l 。(eg: int a = 10; long a = 10L);
▶▶ 如果直接将一个较小的整形常量（在byte，short范围内的数据）赋给一个byte或short类型的整型变量，系统自动将该值当做byte或short类型来处理。如果系统使用一个巨大的数据，超过了int的范围，Java不会自动将他当做long类型处理，要想当成long类型必须在后面加上L或l。
案例:
byte a = 56;//正确
short b = 3000;//正确
long c = 300000000000000000;//错误，系统还是将300000000000000000
//int类型处理，但是300000000000000000超过了int的//范围，所以会报错，必须在300000000000000000后面加//上L或l系统才会把300000000000000000当做long类型
▶▶Java中整形常量有三种表示方式:十进制、八进制、十六进制
默认是十进制，八进制数据以0开头，十六进制数据以0x或0X开头
案例：
public class Test1{
publicstatic void main(String[] args){
int a = 12;
int b = 012;
int c = 0x12;
System.out.println(a);//12
System.out.println(b);//10
System.out.println(c);//18
}
}
五、变量的声明，初始化，作用域，常量
▼变量声明
eg:
int days;//天数
int age;//年龄
int a,b,c;
▼初始化
eg：
days = 25;
age = 18;
a = 10;
b = 10;
c = 5;
可以将变量声明和初始化合并成一部完成
int days = 25;
int age = 18;
int a=10,b=10,c=5;
注意:声明了一个变量后，一定要初始化才可以使用改变量。
eg:
public class Test2{
publicstatic void main(String[] args){
int a;
System.out.println(a); //此处报错 （可能尚未初始化变量 a）
}
}
▼动态初始化
eg： int a = 10;
int b = a;
整型变量b的初始化是将a的值赋给了b，这就是动态初始化。
注意如果a没有初始化，就不允许用a作为其他变量的初始化值。
eg：int a;
int b = a;//此处报错
▼常量
常量:不能改变的量，值是固定的。
public class Test2{
public staticvoid main(String[] args){
int a = 10;
final int MONTHS = 12;//常量 （常量名一般大写，便于和普通变量区分）
System.out.println("a="+a+",MONTHS ="+ MONTHS);
a = 20;
MONTHS = 15;//报错 无法为最终变量 months 指定值(常量的值不可以改变)
System.out.println("a="+a+",MONTHS ="+ MONTHS);
}
}
六、数据类型的转换
Java八种基本数据类型有两种转换方式:自动类型转换、强制类型转换
boolean类型不可以和其他任何类型相互转换。
▼自动类型转换
条件:a.类型兼容
b.目标类型大于源类型
eg:
bytea = 12;
intb = a;//自动类型转换
inta = 123;
doubleb = a;//自动类型转换
▼强制类型转换
有时候需要将大类型的数据转换成小类型使用。Eg:需要将double类型的数据转换成int类型使用，此时可能损失精度，必须使用强制类型转换。注意，强制类型转换不可以乱用。
eg：
double a = 123.5;
int b = (int)a;//强制类型转换
int a = 233;
byte b = (byte)a;//强制类型转换，结果是(-23) 因为byte范围是-128到127 损失精度
▼表达式类型提升
î 当使用二元运算符对两个值进行运算时，两个操作数会转换成通用类型。
î 如果两个操作数中有一个是double类型，则另一个将会转换成double型；
î 如果两个操作数中有一个是float类型，则另一个将会转换成float型；
î 如果两个操作数中有一个是long类型，则另一个将会转换成long型；
î 否则，两个操作数都转换成int型。
î 字符串和所有基本数据类型，基本数据类型都会转换成字符串。
eg:
System.out.println("abc"+1+2);//输出 abc12
System.out.println("abc"+(1+2));//输出 abc3
案例:
public class Demo1{
publicstatic void main(String[] args){
int a,b;
double c,d;
a = 10/3;
b = (int)(10/3.0); //强制类型转换
c = 10/3; //自动类型转换
d = 10/3.0;
System.out.println(a);
System.out.println(b);
System.out.println(c);
System.out.println(d);
}
}
七、运算符的使用
▼算术运算符 + - * / %
加 减 乘 除 取模(取余)
▼自增自减运算符++ --
自增 自减
案例一:
int i = 5;
i++;
System.out.println(i);//6
inti = 5;
++i;
System.out.println(i);//6
总结:单独写i++ 或者 ++i 没有任何区别
案例二:
int i = 5;
int j = i++;//j=i i=i+1
System.out.println("i="+i+" j="+j);//i=6 j=5
int i = 5;
int j = ++i;//i=i+1 j=i
System.out.println("i="+i+" j="+j);//i=6 j=6
总结:在运算时 j = i++ 相当于先把i的值给到j，再让i自增
j = ++i 相当于先把i的值自增，在把i的值给到j
案例三:
int i = 5;
System.out.println(i++);//5
int i = 5；
System.out.println(++i);//6
总结:在输出时，i++相当于先输出i，在让i自增
++i 相当于先让i自增，在输出i
▼关系运算符> >= < <= == !=
大于 大于等于 小于 小于等于 等于 不等
关系表达式得到的结果是true或false
▼逻辑运算符&& || ！ ^ & |
与 或 非 异或 与 或
&& 和 || 是按照短路的方式来求值的。如果第一个操作数已经能够确定表达式的值，则不会计算第二操作数。
eg：（5>6） && (5>1)
前面5>6已经为false，已经可以确定整个表达式的值为false后面就不计算。
& 和 | 是按照非短路方式来求值的。即使第一个操作数已经能够确定表达式的值，还是要计算第二个操作数。
eg：（5>6） & (5>1)
前面5>6已经为false，已经可以确定整个表达式的值为false后面仍然要计算。
^：两个操作数不同返回true，相同返回false
eg:
(5>6) ^ (5>7) false
(5<6) ^ (5<7) false
(5>6) ^ (5<7) true
▼位运算符& | ^
位运算符用于整数之间的位运算，将两个整数转换成2进制来运算
&按位求与 (两个1就为1 ，其他都为0)
| 按位求或 (有一个1 就为1)
^异或 (两个相同为0 不同为1)
eg：
5& 7 = 5 5|7= 7 5^7= 2
101 101 101
& 111 | 111 ^ 111
--------- ------------- ------------
101 111 010
▼赋值运算符=
注意将 = 和 ==区分开来。= 是赋值 == 是判断是否相等
补充:键盘输入数字
import java.util.*;//1.导入包
public class Demo1{
public static voidmain(String[] args){
int a;
Scanner s = new Scanner(System.in);//2.初始化一个对象 s
System.out.println("请输入a的值:");
a = s.nextInt();//3.从键盘输入一个值给到a
System.out.println("你从键盘输入的值是:"+a);
}
}
import java.util.*;//1.导入包
public class Demo1{
public static voidmain(String[] args){
int a,b,sum;
Scanner s = new Scanner(System.in);//2.初始化一个对象 s
System.out.println("请输入a的值:");
a = s.nextInt();//3.从键盘输入一个值给到a
System.out.println("请输入b的值:");
b = s.nextInt();//3.从键盘输入一个值给到b
sum = a+b;
System.out.println(sum);
}
}
一、 程序的三种结构
基本上所有编程语言中，程序都有三种结构：顺序结构、分支(选择)结构、循环结构。Java也不例外。
顺序结构：自上而下的逐行执行代码。
选择结构：根据逻辑判断，有选择的执行其中某部分代码。
循环结构：根据逻辑判断，重复执行某个代码块。
二顺序结构程序设计
前面案例中代码块中没有用if、switch、for、while等的，都是顺序结构
eg:从键盘输入一个三位整数，求出它的个位、十位、百位。
import java.util.*;
public class Demo1{
public static void main(String[]args){
int a,gw,sw,bw;
System.out.println("请输入一个三位整数:");
Scanner s = newScanner(System.in);
a = s.nextInt();
gw = a%10;// 123%10=3
sw = (a/10)%10;// 123/10=12 12%10=2
bw = a/100;// 123/100=1
System.out.println(a+"的个位="+gw+",十位="+sw+",百位="+bw);
}
}
三、 分支(选择)结构程序设计
★ if分支结构
▼单分支
语法:
if（表达式）{
代码块；
}
说明:
如果表达式为true，执行if中的代码块，否则不执行
案例: 从键盘输入小明的Java语言考试成绩score，如果score>=60 就输出"恭喜你，考试及格!";
import java.util.*;
public class Test6{
publicstatic void main(String[] args){
int score;
Scanner s = new Scanner(System.in);
System.out.println("请输入小明的Java成绩:");
score = s.nextInt();
if(score>=60){
System.out.println("恭喜你，考试及格!");
}
}
}
▼二路分支
语法:
if（表达式）{
代码块1;
}else{
代码块2;
}
说明:
如果表达式为true，执行if中的代码块1
如果表达式为false，执行else中代码块2
案例一: 从键盘输入小明的Java语言考试成绩score，如果score>=60 就输出"恭喜你，考试及格!"; 否则就输出"很抱歉，准备补考!"
import java.util.*;
public class Test1{
publicstatic void main(String[] args){
int score;
Scanner s = new Scanner(System.in);
System.out.println("请输入小明的java成绩:");
score = s.nextInt();
if(score>=60){
System.out.println("恭喜你，成绩合格!");
}else{
System.out.println("很抱歉，准备补考!");
}
}
}
▼嵌套分支结构
public class Test7{
publicstatic void main(String[] args){
int a=10,b=15,c=20;
if(a>b){
if(a>c){
System.out.println("最大值="+a);
}else{
System.out.println("最大值="+c);
}
}else{
if(b>c){
System.out.println("最大值="+b);
}else{
System.out.println("最大值="+c);
}
}
}
}
★switch
语法:
switch(表达式){ // JDK6 中表达式类型只能为 byte short int char
case 值1: // JDK7中表达式类型只能为 byte short int char String
语句块1;break;
case 值2:
语句块2;break;
……
……// 中间可以有n个case
……
default: //最后这个default可有可无
语句块n;
}
说明:
根据switch后面括号中表达式的值去依次和case后面的值比较，如果遇到了匹配的就从这个case进入，执行后面的代码块，不再判断是否与后面的case，default标签后面的值是否匹配，直到遇到break才停止。如果没有遇到匹配的值则执行default中的代码块。
案例一: 从键盘输入月份month,输出对应的季节
3.4.5 春季 6.7.8 夏季 9.10.11 秋季 12.1.2 冬季
import java.util.*;
public class Test5{
publicstatic void main(String[] args){
int month;
Scanner input = new Scanner(System.in);
System.out.println("请输入月份:");
month = input.nextInt();
switch(month){
case3:
case4:
case5:
System.out.println("春季");
break;
case6:
case7:
case8:
System.out.println("夏季");
break;
case9:
case10:
case11:
System.out.println("秋季");
break;
case12:
case1:
case2:
System.out.println("冬季");
break;
default:
System.out.println("你的输入有误!");
}
}
}
四、 循环结构程序设计
★ while
语法:
while(表达式){
循环体
}
说明:
判断表达式的值如果为true，执行循环体，循环体执行完了又回到前面判断表达式的值，如果表达的值为true，又执行循环体……依此循环，直到表达式的值为false，循环结束。
案例一:编写程序，求出1+2+3+….+100的和
public class Test13{
publicstatic void main(String[] args){
int i = 1;
int sum = 0;
while(i<=100){
sum= sum+i;
i++;
}
System.out.println(sum);
}
}
★ do…while
语法:
do{
循环体
} while(表达式);
说明:
先执行循环体，循环体执行完了判断表达式，如果表达的值为true，又回到前面执行循环体，循环体执行完了又判断表达式……依此循环，直到表达式的值为false，循环结束
案例一:编写程序，求出1+2+3+….+100的和
public class Test15{
publicstatic void main(String[] args){
int i = 1;
int sum = 0;
do{
sum= sum+i;
i++;
}while(i<=100);
System.out.println(sum);
}
}
★ for
语法:
for(语句1;语句2;语句3){
循环体；
}
语句1:初始化循环变量
语句2:循环条件
语句3:循环增量
说明:
首先执行语句1，
再判断语句2，如果2为true，执行循环体。
循环体执行完了，执行语句3，
语句3执行完了又判断语句2，如果2为true，又执行循环体。
依此循环，直到语句2为false，循环结束。
案例一:编写程序，求出1+2+3+….+100的和
public class Test17{
publicstatic void main(String[] args){
int sum = 0;
for(int i=1;i<=100;i++){
sum= sum+i;
}
System.out.println(sum);
}
}
★ 嵌套循环
案例一:编写程序，打印出九九乘法表
public class Test19{
publicstatic void main(String[] args){
for(int i = 1;i<=9;i++){
for(intj = 1;j<=i;j++){
System.out.print(j+"*"+i+"="+i*j+"");
}
System.out.println();
}
}
}
五、 循环控制break、continue
break:可以在switch中使用，还可以用来结束循环
案例一:
for(inti = 1;i<=5;i++){
if(i==3){
break;
}
System.out.print(i+” ”);
}
运行结果: 1 2
continue:结束当前这一次循环
案例二:
for(inti = 1;i<=5;i++){
if(i==3){
continue;
}
System.out.println(i+” ”);
}
运行结果: 1 2 4 5
案例三:Java中菜单跳转
import java.util.*;
public class Test19{
publicstatic void main(String[] args){
boolean flag = true;
int i;
Scanner s = new Scanner(System.in);
while(flag){
System.out.println("1.取 款");
System.out.println("2.存 款");
System.out.println("3.查 询");
System.out.println("4.退 卡");
System.out.println("请选择你需要的操作:(1--4)");
i= s.nextInt();
switch(i){
case 1:
System.out.println("你选择了取款!");
break;
case 2:
System.out.println("你选择了存款!");
break;
case 3:
System.out.println("你选择了查询!");
break;
case 4:
System.out.println("你选择了退卡!");
flag= false;
break;
default:
System.out.println("你输入有无，请重新输入!");
}
}
}
}
六、 数组、一维数组
数组是所有编程语言中最常见的一种数据结构，他用于存储多个数据。
Java中数组要求数组中的元素类型要一致。Java中一旦数组初始化完成，数组在内存中所占用的空间被固定下来了，因此数组的长度不可变的。
★ 数组的定义、初始化。
▼数组定义
语法:
类型[] 数组名;//常用 int[] a;
类型数组名[];//不常用 int a[];
▼数组初始化
●静态初始化
初始化数组时由程序员显示的指定每个数组元素的值，不指定数组的长度，长度由系统自己计算。
案例一:
int[]a;
a = new int[]{1,2,3};
案例二:
int[] a = new int[]{1,2,3};
int[] a = {1,2,3};//简写 最常用
案例三://错误的
int[]a;
a= {1,2,3};
●动态初始化
初始化数组时程序员只指定数组长度，不指定数组元素的值，系统自动给数组分配初始值。
案例一:
int[]a;
a= new int[5];
案例二:
int[]a = new int[5];
系统初始值:
byte、short、int、long -------> 0
float、double -------> 0.0
char -------> ‘\u0000’ 对应空
boolean -------> false
引用类型:数组、类、接口-----> null
★ 访问数组元素
数组中每个元素都有一个下标，下标从0开始。
▼访问单个元素
int[]a = {56,78,23,50,95};
56 -------- a[0]
78 -------- a[1]
23 -------- a[2]
50 -------- a[3]
95 -------- a[4]
案例:
public class Test1{
public staticvoid main(String[] args){
int[] a = {56,78,23,50,95};
System.out.println(a[0]);//56
System.out.println(a[1]);//78
System.out.println(a[4]);//95
}
}
▼访问所有元素
要输出数组中所有元素，需要使用循环
案例:
public class Test1{
public staticvoid main(String[] args){
int[] a = {56,78,23,50,95};
for(int i = 0;i<=4;i++){
System.out.println(a[i]);
}
}
}
说明:在做循环时，如果数组很长怎么办？怎么知道循环多少次？ 在Java中数组有一个属性length,它记录了数组的长度。利用length就很方便.
int[] a = {56,78,23,50,95};
System.out.println(a.length);//5
输出数组所有元素一般按照下面方式:
public class Test1{
public staticvoid main(String[] args){
int[] a = {56,78,23,50,95};
for(int i = 0;i<=a.length-1;i++){
System.out.println(a[i]);
}
}
}
补充:在JDK5之后加入一个foreach循环，可以输出数组
public class Test1{
public staticvoid main(String[] args){
int[] a = {56,78,23,50,95};
for(intb:a){//foreach循环
System.out.println(b);
}
}
}
★ 数组应用
▼数组求和
eg:有一组学生成绩如下:78,65,96,52,88 求出这组学生成绩的总分
public class Test{
publicstatic void main(String[] args){
int sum = 0;
int[] a = {78,65,96,52,88};
for(int i = 0;i<=a.length-1;i++){
sum= sum+a[i];
}
System.out.println("总分="+sum);
}
}
▼数组求平均分
eg:有一组学生成绩如下:78,65,96,52,88 求出这组学生成绩的平均分
public class Test{
publicstatic void main(String[] args){
int[] a = {78,65,96,52,88};
int sum = 0;
double avg;
//总分
for(int i = 0;i<=a.length-1;i++){
sum= sum+a[i];
}
System.out.println("总分="+sum);
//平均分
avg = sum/(a.length*1.0);
System.out.println("平均分="+avg);
}
}
▼数组求最大、最小值
public class Test{
publicstatic void main(String[] args){
int[] a = {78,65,96,52,88};
int max = a[0];//假设a[0]最大
int min = a[0];//假设a[0]最小
//求最大值、最小值
for(int i = 0;i<=a.length-1;i++){
if(a[i]>max){
max = a[i];
}
if(a[i]<min){
min = a[i];
}
}
System.out.println("最高分="+max);
System.out.println("最低分="+min);
}
}
▼查找某个数据是否在数组中
eg:有一组学生成绩如下:78,65,96,52,88 从键盘输入一个分数，查找该数组是否在这组成绩中
import java.util.*;
public class Test{
publicstatic void main(String[] args){
int[] a = {78,65,96,52,88};
boolean f = false;
Scanner s = new Scanner(System.in);
System.out.println("请输入你要查找的值:");
int x = s.nextInt();
//比较
for(int i = 0;i<=a.length-1;i++){
if(a[i]==x){
f = true;
}
}
//判断
if(f){
System.out.println("找到了!");
}else{
System.out.println("没有找到!");
}
}
}
▼分段统计
eg:有一组学生成绩:78,65,96,52,88 统计出及格人数和不及格人数
import java.util.*;
public class Test{
publicstatic void main(String[] args){
int[] a = {78,65,96,52,88};
int count1=0,count2=0;
for(int i = 0;i<=a.length-1;i++){
if(a[i]>=60){
count1++;
}else{
count2++;
}
}
System.out.println("及格人数="+count1);
System.out.println("不及格人数="+count2);
}
}
eg:有一组学生成绩:78,65,96,52,88 统计出不低于平均分人数，低于平均分人数
import java.util.*;
public class Test{
publicstatic void main(String[] args){
int[] a = {78,65,96,52,88};
int count1=0,count2=0;
int sum =0 ;
double avg;
//总分
for(int i = 0;i<=a.length-1;i++){
sum= sum+a[i];
}
//平均分
avg = sum/(a.length*1.0);
System.out.println("总分="+sum+",平均分="+avg);
//统计
for(int i = 0;i<=a.length-1;i++){
if(a[i]>=avg){
count1++;
}else{
count2++;
}
}
System.out.println("不低于平均分人数="+count1);
System.out.println("低于平均分人数="+count2);
}
}
eg:有一组学生成绩如下:78,65,96,52,88 统计出90--100分 80--89分 60--79分 0--59分各个分数段人数
import java.util.*;
public class Test{
publicstatic void main(String[] args){
int[] a = {78,65,96,52,88};
intcount1=0,count2=0,count3=0,count4=0;
//统计
for(int i = 0;i<=a.length-1;i++){
if(a[i]>=90){
count1++;
}elseif(a[i]>=80){
count2++;
}elseif(a[i]>=60){
count3++;
}else{
count4++;
}
}
System.out.println("90--100分人数="+count1);
System.out.println("80--89 分人数="+count2);
System.out.println("60--79 分人数="+count3);
System.out.println(" 0--59 分人数="+count4);
}
}
▼冒泡排序
eg:有一组学生成绩如下:89,75,64,32,78 将改组学生成绩从低到高排序
import java.util.*;
public class Test{
publicstatic void main(String[] args){
int[] a = {78,65,96,52,88};
//冒泡排序(从小到大)
for(int i = 0;i<a.length-1;i++){
for(intj = 0;j<a.length-1;j++){//此处可以优化 for(int j = 0;j<a.length-1-i;j++)
if(a[j]>a[j+1]){
inttemp = a[j];
a[j]= a[j+1];
a[j+1]= temp;
}
}
}
//输出
for(int i = 0;i<=a.length-1;i++){
System.out.print(a[i]+" ");
}
System.out.println();
}
}
eg:有一组学生成绩如下:89,75,64,32,78 将改组学生成绩从高到低排序
import java.util.*;
public class Test{
publicstatic void main(String[] args){
int[] a = {78,65,96,52,88};
//冒泡排序(从大到小)
for(int i = 0;i<a.length-1;i++){
for(intj = 0;j<a.length-1;j++){//此处可以优化 for(int j =0;j<a.length-1-i;j++)
if(a[j]<a[j+1]){
inttemp = a[j];
a[j]= a[j+1];
a[j+1]= temp;
}
}
}
//输出
for(int i = 0;i<=a.length-1;i++){
System.out.print(a[i]+" ");
}
System.out.println();
}
}
▼数组内存分析
栈:基本数据类型变量值，引用类型变量的地址值
堆:引用类型的真实值
案例一:
publicclass TestArray1{
public static void main(String[] args){
int[] a = {89,75,64,32,78};
System.out.println(a[3]);
}
}
案例二:
public class TestArray1{
public static void main(String[] args){
int[]a = {89,75,64,32,78};
int[]b = {55,66,77,88};
System.out.println(a[2]);
System.out.println(b[2]);
}
}
案例三:
public class TestArray1{
public static void main(String[] args){
int[]a = {89,75,64,32,78};
int[]b = a;
System.out.println(a[3]);//32
System.out.println(b[3]);//32
a[1]= 100;
System.out.println(a[1]);//100
System.out.println(b[1]);//100
b[3]= 50;
System.out.println(a[3]);//50
System.out.println(b[3]);//50
}
}
案例四:
publicclass TestArray1{
public static void main(String[] args){
int[]a = {89,75,64,32,78};
int[]b = {55,66,77};
System.out.println(a[1]);//75
System.out.println(b[1]);//66
b= a;
System.out.println(a[1]);//75
System.out.println(b[1]);//75
b[1]= 30;
System.out.println(a[1]);//30
System.out.println(b[1]);//30
}
}
七、 二维数组、多维数组
Java中没有多维数组。一维数组中放的是多个普通变量，二维数组中放的是多个一维数组，三维数组中放的是多个二维数组……
★二维数组
比叫下面案例:
public class Test{
publicstatic void main(String[] args){
int a = 10;//a是普通变量
int[] b = {1,2,3};//b是一维数组
// b[0] b[1]b[2] 一维数组中的元素（相当于a）
int[][] c ={{1,2,3},{7,8},{10,20,30}};// c二维数组
// c[0] c[1] c[2] 一维数组（相当于b）
// c[0][0] c[1][1]c[2][2] 一维数组中的元素（相当于b[0]）
System.out.println(a);//10
System.out.println(b[1]);//2
System.out.println(c[2][1]);//20
}
}
▼二维数组定义
语法:
类型[][] 数组名;//常用 int[][] a;
类型数组名[][];//不常用 int a[][];
▼数组初始化
●静态初始化
初始化数组时由程序员显示的指定每个数组元素的值，不指定数组的长度，长度由系统自己计算。
案例一:
int[][]a;
a = new int[][]{{1,2,3},{5,6},{10,20,30}};
案例二:
int[][]a = new int[][]{{1,2,3},{5,6},{10,20,30}}; int[][] a ={{1,2,3},{5,6},{10,20,30}};//简写 最常用
案例三://错误的
int[][]a;
a= {{1,2,3},{5,6},{10,20,30}};
●动态初始化
初始化数组时程序员只指定数组长度，不指定数组元素的值，系统自动给数组分配初始值。
案例一:
int[][]a;
a= new int[3][2];
案例二:
int[][]a = new int[3][2];
案例一:输出二维数组中的所有元素
public class Test{
public static void main(String[] args){
int[][]c = {{1,2,3},{7,8},{10,20,30,40}};// c二维数组
// c[0] c[1] c[2] 一维数组
// c[0][0] c[1][1] c[2][2] 一维数组中的元素
//输出了二维数组中所有一位数组
for(inti = 0;i<=c.length-1;i++){
//输出一位数组c[i]的元素
for(int j = 0;j<=c[i].length-1;j++){
System.out.print(c[i][j]+" ");
}
System.out.println();
}
System.out.println();
}
}
一.类和对象
◆思考:世界是由什么组成的?
答:人、动物、植物……
分类是人们认识事物的一个很自然的过程，在日常生活中人们会自觉或不自觉的对事物分类。
◆类:类是具有相同属性和行为的一组对象的集合与抽象。
（系统定义的类，用户自定义的类）
◆对象:对象是一个具体存在的实体，他是类的实例化，用来描述一个客观事物的实体，由一组属性和方法构造。（万物皆对象）
◆类与对象的关系:
类是对对象的描述，是创建对象的“模板”，是对象的抽象；对象是表示现实世界中某个具体的事物，是类的一个实例，是类的实例化结果。
二.类的定义
◆语法:
[修饰符] class 类名 [继承][接口]{
0—n个属性;
0---n个方法;
}
◆案例:
public class Box {
//属性
public int l;//长
public int w;//宽
public int h;//高
//方法(求出体积)
public void getV(){
System.out.println("体积="+l*w*h);
}
//方法(求出表面积)
public void getS(){
System.out.println("表面积="+2*(l*w+l*h+w*h));
}
}
三.对象的创建
1.声明的对象
Box b;//int a;
Box b1,b2;//int a,b;
2.对象的创建
b = new Box();// a = 10;
b1 = new Box();
b2 = new Box();//a = 10,b=20;
注意:一般都是一二部一起完成
Box b = new Box();//int a = 10;
3.对象的使用
使用对象可以通过.来访问自己的属性和方法。
Eg:
b.l = 10;//访问属性
b.w = 5;
b.getV();//访问方法
◆综合案例:类和对象
public class Box {
//属性
public int l;//长
public int w;//宽
public int h;//高
//方法(求出体积)
public void getV(){
System.out.println("体积="+l*w*h);
}
//方法(求出表面积)
public void getS(){
System.out.println("表面积="+2*(l*w+l*h+w*h));
}
public static void main(String[] args){
Box b = new Box();//创建一个对象
b.l = 10;//给属性赋值
b.w = 8;
b.h = 5;
b.getV();//调用方法
b.getS();
}
}
四.内存分析
案例一:
一、 方法的概念、作用
▼方法:
方法类似于高中数学中的函数，它就是一段完成某种功能的代码的集合。
▼方法作用:
简化代码，提高程序的可读性，有利于代码之间共享。
二、 方法的定义
★语法:
[修饰符] 返回值类型方法名([参数列表]) [throws 例外1,例外2]{
方法体;
[return返回值;]
}
★说明:
修饰符:public、static、final……
返回值类型:如果该方法有返回值，则标明返回值类型
如果该方法没有返回值，则使用void
方法名:就是方法的名字(方法名是自己定义的，但是方法名不可以乱写，必须遵循:
1. 第一个字母小写
2. 如果使用多个单词，除第一个单词外其他单词第一个字母大写
3. 使用的单词最好能够明确表达出该方法的主要功能，不要怕方法名长eg:drawCircleAndRectangle())
参数列表:有的方法调用它时需要传入参数，此时就需要在方法列表中写好对应的参数列表，有的方法不需要传入参数就不需要参数列表。
throws 例外1,例外2:暂时不用考虑
方法体:完成该方法功能的代码块，是方法中最重要的部分。
return 返回值:如果前面返回值类型为void，则不需要返回值
如果前面返回值类型不为void，则需要返回对应类型的参数
案例:
public class Fuction {
//最简单的方法
void fun1(){
System.out.println("HelloWorld!");
}
//带修饰符的方法
public void fun2(){
System.out.println("你好!");
}
//带修饰符的方法
public static void fun3(){
System.out.println("大家好!");
}
//带参数的方法
public void fun4(int x,int y){
int sum = x+y;
System.out.println(sum);
}
//带返回值的方法
public int fun5(int x,int y){
int sum = x+y;
return sum;
}
//主方法
public static void main(String[] args) {
Fuction f = new Fuction();
f.fun1();//调用方法
f.fun2();
f.fun3();
f.fun4(10, 20);
int x = f.fun5(20, 30);//调用有返回值的方法
System.out.println(x);
}
}
总结:方法有没有修饰符，有没有返回值，有没有参数……都是我们自己根据实际情况可以控制的，怎样简单就怎样写。
三、 方法的调用
★在面向过程的编程语言中(eg:C),程序是由一个一个的函数(方法)组成的,方法可以直接调用。
★在面向对象的编程语言中(eg:Java),程序是由一个一个的类组成的，方法不可以单独调用。一个方法必定属于一个类或者一个对象。调用方法时，必须使用类或者对象作为调用者，及必使用 “类.方法” 或者“对象.方法”。
★静态方法和普通方法:
▲如果方法前面加了修饰符“static”，代表该方法是静态方法，静态方法属于类。调用静态方法时可以使用类来调用，也可以使用对象来调用，如果前面没有指明调用则默认为当前类调用。
案例:
public class Test1 {
public static void add(int a,int b){//静态方法 类方法
int sum = a+b;
System.out.println(sum);
}
public static void main(String[] args){
Test1.add(10,20);//使用类名调用
Test1 t = new Test1();
t.add(20,30);//使用对象调用
add(30,40);//没有指明调用者，默认为类调用 Test1.add(30,40);
}
}
▲如果方法前面没有加修饰符“static”，代表该方法是普通方法，普通方法属于对象。在静态方法中调用普通方法只能使用对象调用；在普通方法中调用普通方法 可以使用对象调用，可以使用this调用，也可以直接调用（默认缺省this,this就是指的当前对象）。
案例:
public class Test1 {
public void fun1(){
System.out.println("Hello World!");
}
public void fun2(){
Test1 t = new Test1();
t.fun1();//对象调用方法
this.fun1();//this调用
fun1();//直接调用默认缺省this
System.out.println("你好!");
}
public static void main(String[]args) {
Test1 t1 = new Test1();
t1.fun2();//对象调用
}
}
★返回值
▲有的方法返回值类型为void，代表没有返回值，则直接调用即可。
▲有的方法返回值类型不为void，代表该方法有返回值，调用时需要定义相应类型变量接收返回值再输出，或者直接输出。
案例:
public class Test1 {
public void fun1(int a,int b){
int sum = a+b;
System.out.println(sum);
}
public int fun2(int a,int b){
int sum = a+b;
return sum;
}
public static void main(String[]args) {
Test1 t = new Test1();
t.fun1(10,20);//调用没有返回值的方法 直接调用
int x = t.fun2(20,30);//调用有返回值的方法 定义相应类型变量接收
System.out.println(x);//输出接收的值
System.out.println(t.fun2(20,30));//调用有返回值的方法 直接输出
}
}
★参数列表
▲有的方法没有参数列表，则直接调用即可
▲有的方法有参数列表，则调用时需要传入相应类型的参数
public class Test1 {
public void fun1(){
System.out.println("Hello World!");
}
public void fun2(int a,int b){
int sum = a+b;
System.out.println(sum);
}
public static void main(String[]args) {
Test1 t = new Test1();
t.fun1();//调用没有参数列表的方法直接调用
t.fun2(10,20);//调用有参数列表的方法需要传入相应类型的参数
}
}
总结:
调用方法“三看”
一看 static
有:是静态方法 类.方法 对象.方法 方法(默认缺省类名)
没有:普通方法
1.静态方法中调 对象.方法
2.普通方法中调 对象.方法 this.方法 方法(默认缺省this)
二看返回值类型
没有: 正常调用
有: 定义相应类型变量接收
直接输出
三看参数列表
没有:正常调用
有：传入相应类型变量
四、 方法的参数传递
在定义方法时，如果方法中有参数列表，则调用方法时需要传入相应类型的参数。
形参:（形式参数）定义方法时，方法参数列表中的参数
实参:（实际参数）调用方法时，传递给形参的值就是实参
Eg：
public class Test1 {
public void fun1(int a,int b){//a,b是形参
int sum = a+b;
System.out.println(sum);
}
public static void main(String[]args) {
Test1 t = new Test1();
int x = 10;
int y = 20;
t.fun1(x,y);//x,y是实参
}
}
Java中方法的参数传递方式只有一种:值传递(真实值、地址值)。
所谓值传递，就是将实际参数值的副本(复制品)传入方法内，而参数本身不会受到影响。
▲案例一:值传递—真实值
public class Test1 {
public static void fun1(int a){
System.out.println("变化前a="+a);
a = 200;
System.out.println("变化后a="+a);
}
public static void main(String[]args) {
int x = 100;
System.out.println("变化前x="+x);
fun1(x);
System.out.println("变化后x="+x);
}
}
运行结果:
变化前x=100
变化前a=100
变化后a=200
变化后x=100
五、 方法重载
思考如下代码
public class Test1 {
public static void addTwoInt(int a,int b){
System.out.println(a+b);
}
public static void addThreeInt(int a,int b,int c){
System.out.println(a+b+c);
}
public static void addTwoDouble(double a,double b){
System.out.println(a+b);
}
public static void addThreeDouble(double a,double b,double c){
System.out.println(a+b+c);
}
public static void main(String[] args) {
addTwoInt(10,20);
addTwoDouble(10.5,9.6);
}
}
该案例中有四个方法都是求和，但是方法名都不一样，我们在加法时，还需要去考虑调用那个方法，十分麻烦，而且容易出错。能不能让相同功能的方法名都一样呢？这里就需要用到重载。
Java中允许定义多个同名的方法，只需要这些方法参数列表不一样即可，这个就叫方法的重载。（参数列表不一样可以是:1.参数个数不一样 2.参数类型不一样 3.参数顺序不一样）
六、 构造方法的概念和作用
▼构造方法:
构造方法是一个用来初始化一个对象的内部状态的特殊方法(给属性赋值)。
构造方法时创建对象的根本，创建对象其实都是使用new 构造方法() 来完成的。
▼语法
[修饰符] 方法名([参数列表]){ //构造方法名必须和类名一致
//方法体
}
▼案例
没有自定义构造方法
自定义构造方法
七、 构造方法的特点
▼1.构造方法名必须和类名一致
public People(String name,char sex,int age){//构造方法名必须和类名一致
this.name = name;
this.sex = sex;
this.age = age;
}
▼2.构造方法没有返回值，也不能写void
▼3.构造方法不能被程序员显示的直接调用
public static void main(String[] args) {
Peoplep = new People("李天鹏",'男',17);
p.tell();
p.People("李天鹏",'男',17);//报错
}
▼4.Java语言中，每个类至少有一个构造方法。(如果没有构造方法，则不能创建对象)
▼5.如果类的定义者没有显示的定义任何构造方法，则Java编译器会自动为该类提供一个默认为空的构造方法。（没有参数列表，没有方法体）
Eg:
public People(){
}
▼6.如果类的定义者显示定义了一个或多个构造方法，则系统不再提供默认为空的构造方法。
public class People {
public String name;
public char sex;
public int age;
public People(String name,char sex,int age){
this.name = name;
this.sex = sex;
this.age = age;
}
public void tell(){
System.out.println("我叫:"+name+",性别:"+sex+",年龄:"+age);
}
public static void main(String[] args) {
Peoplep = new People("李天鹏",'男',17);
p.tell();
Peoplep = new People();//报错,程序员自己定义了一个构造方法，则系统不再提供为空的。
}
}
八、 构造方法的重载
方法的重载就是在同一个类中允许同时存在一个以上的同名方法，只要它们的参数个数或者类型不同即可。在这种情况下，该方法就叫被重载了，这个过程称为方法的重载（overloading）
Java编译器能根据调用方法时所传递的参数个数和类型选择相应的方法。
public class People {
//属性
public String name;
public char sex;
public int age;
//构造方法重载
public People(){
}
public People(String name,char sex){
this.name = name;
this.sex = sex;
}
public People(String name,char sex,int age){
this.name = name;
this.sex = sex;
this.age = age;
}
//普通方法
public void tell(){
System.out.println("我叫:"+name+",性别:"+sex+",年龄:"+age);
}
public static void main(String[] args) {
People p1 = new People("李天鹏",'男',17);
p1.tell();
People p2 = new People("侯盼盼",'女');
p2.tell();
People p3 = new People();
p3.name = "秦斌";
p3.sex = '男';
p3.age = 18;
p3.tell();
}
}
九、 构造方法的调用
在一个构造方法中调用另外一个构造方法,不是使用构造方法名,而是使用this(参数)的形式。
注意:
在一个构造方法中调用另一个构造方法，this(参数)必须位于第一行。
不能再够方法以为的任何地方调用构造方法
在一个构造方法中最多只能使用一个this调用一个构造方法。
public class Student {
public String no;//学号
public String name;//姓名
public char sex;//性别
public int age;//年龄
public String address;//籍贯
//构造方法
public Student(){
}
public Student(String no,String name,char sex,int age){
this.no = no;
this.name = name;
this.sex = sex;
this.age = age;
}
public Student(String no,String name,char sex,int age,String address){
this(no,name,sex,age);//调用前面的构造方法publicStudent(String no,String name,char sex,int age){ }
this.address = address;
}
//方法
public void tell(){
System.out.println("学号:"+no+",姓名:"+name+",性别:"+sex+",年龄:"+age+",籍贯:"+address);
}
public static void main(String[] args) {
Student s1 = new Student("KF00125","侯盼盼",'女',17,"河南新乡");
s1.tell();
Student s2 = new Student("KF00128","申金玉",'男',16);
s2.tell();
}
}
在Java语言中，根据变量的位置的不同，可以将变量分为两大类:
成员变量 局部变量
Java中的内存空间:栈、堆、全局数据区、全局代码区
栈:基本数据类型、引用类型的地址
堆:引用类型的真实值(数组的值、对象的属性)
全局数据区:类属性(加了static的属性)
全局代码区:所有的方法的代码
十、 成员变量
★在类的范围里面定义的变量就是成员变量(成员变量就是属性，也可以叫成员属性)
成员变量分为两类:
●类属性: ●实例属性:
在定义一个属性时如果使用static修饰，则就是类属性；如果没有使用static修饰，则就是实例属性(实例就是对象)
类属性的作用域与这个类的生存范围相同，他作为一个类的成员，与类共存亡。只要类存在，程序就可以访问该类的类属性。访问类属性可以使用 类.属性 也可以使用 对象.属性
实例属性从这个类的实例(对象)被创建开始存在，直到系统完全销毁这个实例，它作为实例（对象）的一个成员，与实例（对象）共存亡。只要实例（对象）存在，程序就可以访问该实例的实例属性。访问实例属性可以使用 实例.属性
案例:
package test3_8;
public class Test {
public int a;//实例属性
public static int b;//类属性
public void fun(){
System.out.println("属性加了static就是类属性，没有static就是实例(对象)属性");
}
public static void main(String[] args) {
Test t = new Test();
t.a = 10;//访问实例属性
t.b = 20;//访问类属性
Test.b = 30;//访问类属性
System.out.println(t.a);
System.out.println(t.b);
System.out.println(Test.b);
}
}
类属性和实例属性的区别:类属性保存在全局数据区，实例属性保存在堆中。
案例一:
public class People {
//属性
public String name;
public char sex;
public int age;
public String address;
//构造方法
public People(String name,char sex,int age,String address){
this.name = name;
this.sex = sex;
this.age = age;
this.address = address;
}
public void tell(){
System.out.println("姓名:"+name+",性别:"+sex+",年龄:"+age+",籍贯:"+address);
}
//主方法
public static void main(String[] args) {
People p1 = new People("陈浩然",'男',16,"河南汴京");
People p2 = new People("宗金原",'男',17,"河南汴京");
People p3 = new People("赵雪玲",'女',17,"河南汴京");
System.out.println("------改名前------");
p1.tell();
p2.tell();
p3.tell();
p1.address ="河南开封";
p2.address ="河南开封";
p3.address ="河南开封";
System.out.println("------改名后------");
p1.tell();
p2.tell();
p3.tell();
}
}
运行结果
------改名前------
姓名:陈浩然,性别:男,年龄:16,籍贯:河南汴京
姓名:宗金原,性别:男,年龄:17,籍贯:河南汴京
姓名:赵雪玲,性别:女,年龄:17,籍贯:河南汴京
------改名后------
姓名:陈浩然,性别:男,年龄:16,籍贯:河南开封
姓名:宗金原,性别:男,年龄:17,籍贯:河南开封
姓名:赵雪玲,性别:女,年龄:17,籍贯:河南开封
内存分析
案例二:
public class People {
//属性
public String name;
public char sex;
public int age;
public static String address;
//构造方法
public People(String name,char sex,int age,String address){
this.name = name;
this.sex = sex;
this.age = age;
this.address = address;
}
public void tell(){
System.out.println("姓名:"+name+",性别:"+sex+",年龄:"+age+",籍贯:"+address);
}
//主方法
public static void main(String[] args) {
People p1 = new People("陈浩然",'男',16,"河南汴京");
People p2 = new People("宗金原",'男',17,"河南汴京");
People p3 = new People("赵雪玲",'女',17,"河南汴京");
System.out.println("------改名前------");
p1.tell();
p2.tell();
p3.tell();
People.address ="河南开封";
System.out.println("------改名后------");
p1.tell();
p2.tell();
p3.tell();
}
}
运行结果
------改名前------
姓名:陈浩然,性别:男,年龄:16,籍贯:河南汴京
姓名:宗金原,性别:男,年龄:17,籍贯:河南汴京
姓名:赵雪玲,性别:女,年龄:17,籍贯:河南汴京
------改名后------
姓名:陈浩然,性别:男,年龄:16,籍贯:河南开封
姓名:宗金原,性别:男,年龄:17,籍贯:河南开封
姓名:赵雪玲,性别:女,年龄:17,籍贯:河南开封
内存分析
十一、 局部变量
★在方法的范围里面定义的变量就是局部变量
局部变量分为三类:
●形参:整个方法中有效
●方法局部变量:在方法中，从定义开始到方法结束
●代码块局部变量:在代码块中，从定义开始到代码块结束
案例:
public class Test2 {
public String name;//name成员变量 实例属性堆
public static String address;//address成员变量 类属性 全局数据区
public void fun(int a,int b){//a,b局部变量 形参
int sum = a+b;//sum局部变量 方法局部变量
for(int i = 1;i<=100;i++){//i局部变量 代码块局部变量
System.out.println(i);
}
}
}
总结:局部变量与成员变量的区别
1. 定义变量的位置不同 局部变量在方法中 成员变量在类中
2. 保存变量的位置不同 局部变量在栈中 成员变量在堆和全局数据区中
3. 局部变量（除了形参）必须要初始化才能使用 成员变量可以不用初始化系统会提供默认值
相关文章
- 暂无相关文章
用户点评