Java基础
Java快速入门
\(\textcolor{plum}{Java-基础}\)
\(\textcolor{cyan}{Java入门}\)
Java语言的发展史
java 语言 与 C 语言一样都是用于人与计算机沟通的语言 [类似于英文和中文]
Java之父 --- James Gosling [詹姆斯.高斯林]
Java语言是由美国
sun公司在1995年5月推出的计算机语言
Java名称的由来: 印度尼西亚有一个重要的盛产咖啡的岛屿叫 java, 中文译名为爪哇,开发人员为这种新的语言起名为java
Java的先导知识和后续技术
graph TD;
C语言-->Java语言;
Java语言-->JSP;
Java语言-->Android;
Java语言-->JavaME;
Java语言-->XML;
Java语言-->JavaEE;
java的特点
简单
- 学过C语言基础,C++的同学就会发现Java语言很熟悉,和C语言的功能很类似, 比如三大结构[顺序,选择,循环],
注意:C语言和java是完全不同的语言,都有各自的优势,而且还会长期并存下去面向对象
- 基于对象的编程更符合人的思维模式.更容易解决复杂的问题
平台无关
C语言: 只能对特定的CPU芯片进行编译, 如跟换了芯片,就不能保证程序的正常运行
Java: 在计算机操作系统之上再提供了一个Java运行环境[Java虚拟机], 这样的好处Java语言编写的软件能在
执行码上兼容跨平台原理
Java虚拟机
总结: 在需要运行 java应用程序的操作系统上,安装一个与操作系统对应的Java虚拟机
\(\textcolor{red}{JDK}\)与\(\textcolor{red}{JRE}\)
-
JRE 是\(\textcolor{red}{Java}\)程序的运行时环境,包含\(\textcolor{cyan}{JVM}\) 和运行时所需要的核心类库; 如果我们想要\(\textcolor{red}{运行}\)一个已有的Java程序, 那么只需要安装\(\textcolor{red}{JRE}\) 即可
-
JDK 是\(\textcolor{red}{Java}\)程序的开发工具包,包含\(\textcolor{cyan}{JRE}\) 和开发人员使用的工具;其中的开发工具: 编译工具(Javac.exe)和运行工具(java.exe)
-
\(\textcolor{red}{我们想要开发一个全新的Java程序,那么必须安装JDK}\)
安装JDK
graph LR
a(双击)-->b(下一步)-->c(下一步)-->d(...)
# 下载路径
链接：https://pan.baidu.com/s/1f1ntGs6lV6gxBw_RGn4vQA?pwd=mghf
出现如图所示,表示安装成功
Path环境变量设置
graph LR
a(右击我的电脑)-->b(点击属性)-->c(高级系统设置)-->d(高级)-->e(环境变量)-->f(新建)
测试环境变量
HelloWorld实验案例
graph LR
a(创建一个 .java文本)-->b(编写Java程序)-->c(利用javac命令 编译源文件)-->p(产生字节码)-->d(利用 Java命令 执行字节码)
注意:字节码的文件后缀名为.class
安装IDEA
IDEA官网下载并安装
IDEA中的HelloWorld
步骤:
graph TD; 创建一个空项目--> 创建一个新模块-->在新模块下的src下创建一个包-->在包下创建一个类-->在类里面编写代码-->执行;
-
新建一个空项目
-
设置空项目名称
-
设置Modules
-
创建名称
-
成功创建
IDEA中创建包
- !
IDEA中创建类
IDEA中编写程序
-
public class Helloworld { public static void main(String[] args){ System.out.println("HelloWorld"); } }
IDEA目录结构
基础语法
注释
一般注释: 块注释, 单行注释, 尾端注释
# 块注释 /**注释*/ # 单行注释 // this is apple # 尾端注释 /* this is girl */
例:public class Helloworld { /*创建一个类*/ /*这是一个main方法 main方法是程序的入口方法,代码的执行是从main方法开始的*/ public static void main(String[] args) { //这是一个输出函数 System.out.println("我爱JAva"); } }文档注释: 与块注释类似
关键字
特点: 只能是小写字母 如: public class ... [ 50个左右 ]
标识符
作用: 用来标识类名, 变量名, 方法名, 类型名, 数组名, 文件名 ,简单的说, 标识符就是一个名字
注意:
标识符由字母, 下画线, 美元符号$, 数字组成
标识符的第一个字符不能是数字字符
标识符不能是关键字
标识符是区分大小写的
hello 与 Hello 是不同的标识符
常量分类
-
常量类型 说明 举例 整型常量 整数 1314, -520 浮点型常量 小数 12.13, -0.98 字符型常量 用单引号括起来的内容 'A' '二位' 字符串常量 用双引号括起来的内容 "hfudhbgr" 布尔常量 布尔值, 表示真假 true false 空常量 一个特殊值, 空值 null
变量
变量定义
- 在程序运行过程中, 其值可以改变的量
定义变量并使用
-
格式: 类型名 变量名=变量值 [=====不是等于, 是属于符号]
-
例public class Helloworld { public static void main(String[] args) { int a = 12; //定义变量 System.out.println(a); //输出变量值 } }注意: 变量必须先定义后使用, 没有赋值的变量不能使用
数据类型
-
数据类型 关键字 内存占用 表示形式 整型 byte
short
int
long1
2
4
8byte x=12
short y=45
int z=88
long q=10000L浮点型 float
double4
8float a=13.13f,b=14.14F
double d=15.15(D\d) [默认情况是double类型]字符型 char 2 char q='A' 布尔型 boolean 1 boolean a=true/false
类型转换
类型精度从低到高排列
graph LR
byte-->a(short)-->c(int)-->long-->float-->double
char-->c
-
自动类型转换
public class Helloworld { /*创建一个类*/ public static void main(String[] args) { double a = 12; System.out.println(a); } }D:\Java\JDK\bin\java.exe.... 12.0 Process finished with exit code 0 -
强制类型转换
把一个大的数据类型转换为一个小的数据类型
小 = 大
格式:
- 类型名 变量名 = (类型名)数值或变量
public class Helloworld { /*创建一个类*/ public static void main(String[] args) { double a = 12.14; int b = (int)a; System.out.println(b); } }D:\Java\JDK\bin\java.exe.... 12 Process finished with exit code 0
输入与输出
输入数据
-
Scanner 与 C语言中 scanf 类似, 在Java中把Scanner表示一个类, 用来提供输入
import java.util.Scanner; public class Helloworld { public static void main(String[] args) { System.out.println("请输入一个整数:"); Scanner reader = new Scanner(System.in); int a = reader.nextInt(); System.out.println("这个整数值为"+"\n"+a); } }-
Scanner类在 java.util包中, 在程序中需要 Scanner 的时候,需要在开头书写 import java.util.Scanner; 不然会报错
-
Scanner是一个类,使用 Scanner 类创建一个对象
-
new: 为对象分配变量
-
该对象调用下列方法, 读取用户在命令行输入的各种基本类型数据
nextBoolean(); nextByte(); nextShort(); nextInt(); nextLong(); nextFloat(); nextDouble();
-
输出数据
-
System.out.println(): 允许用 '+' 号将变量, 字符串,表达式或常量并置在一起输出
public class Helloworld { public static void main(String[] args) { System.out.println("I love"+ "java"); System.out.println("I love"+ 34); } } ------------------------------------------------------------------------------------ I lovejava I love34 -
System.out.printf(): 需要使用格式控制符来控制格式
public class Helloworld { public static void main(String[] args) { int a=100; System.out.printf("a=%d",a); } } ------------------------------------------------------------------------------------ a=100常用控制符
控制符 作用 %d 输出 int型数据 %c 输出char型数据 %f 输出浮点型数据[小数部分最多保留6位] %s 输出字符串数据
运算符
'加'减'运算
-
'+' ; '-' : 与数学中的加减运算一样
public class Helloworld { public static void main(String[] args) { int a=100,b=200,sum,sun; sum = a+b; sun = a-b; System.out.printf("a+b=%d\n",sum); System.out.println("a-b="+sun); } }a+b=300 a-b=-100
'乘'除'和'取余'
-
'*' ; '/' ; '%': 注意'除'与数学中的除不一样
public class Helloworld { public static void main(String[] args) { int a=6,b=4,sum,sun; sum = a/b; //取整数部分, 不要余数, 比如 6/4=1...2 取 1 sun = a%b; //取余数 System.out.printf("a/b=%d\n",sum); System.out.println("a%b="+sun); } }a/b=1 a%b=2
自增, 自减运算符
-
'++' ; '--'
'++' ; '--' 可以在前,可以在后
public class Helloworld { public static void main(String[] args) { int a=6,b=4,sum,sun; System.out.println(a++); System.out.println(++b); } }D:\Java\JDK\bin\java.exe ... 6 5 Process finished with exit code 0注意:
- 当 '++' '--' 在前先 +1, 再取值 [++x]
- 当 '++' '--' 在后先取值,再 +1 [x++]
- 粗略的看, x++ 和 ++x 相当于 x=x+1; x++: 先使用x的值, 再执行 x=x+1, ++x: 先执行 x=x+1 ,再使用x的值
算术混合运算
-
精度从
低到高排序graph LR a(byte)-->b(short)-->d(char)-->c(int)-->e(long)-->f(float)-->s(double) -
举例说明
public class Helloworld { public static void main(String[] args) { int a=6,sum; char b='A'; sum = a+b; System.out.printf("a+b=%d\n",sum); System.out.printf("a+b=%c\n",sum); } }这里a是int类型, b是char类型, a+b 以int型输出的时候, 是 71; 以char类型输出的时候是 G
涉及到了一个 ASCII 码表
-
可以看到 A 是 65, G 是 71, 当char与int计算时, 计算机会自动转换为 ASCII 码计算
关系运算符和关系表达式
-
表格
运算符 含义 > 大于 < 小于 > = 大于等于 < = 小于等于 = = 等于 ! = 不等于 关系表达式
当关系表达式成立时, 值为 true, 否则为 false
public class Helloworld { public static void main(String[] args) { int a=6,b=4; System.out.println(a>b); System.out.println(a<b); } }D:\Java\JDK\bin\java.exe .... true false Process finished with exit code 0
逻辑运算符与逻辑表达式
-
表格
运算符 含义 && 逻辑与 || 逻辑或 ! 逻辑非 -
逻辑运算
a b a&&b a||b !a true true true true false true false false true false false true false true true false false false false true 口诀: 逻辑与: 全真才真,一假必假
逻辑或: 全假才假,一真必真
逻辑非: 与Boolean值相反
逻辑表达式
根据逻辑运算符进行运算
public class Helloworld { public static void main(String[] args) { boolean a=true,b=false,c,d; c=a&&b; d=a||b; System.out.println(c); System.out.println(d); } }D:\Java\JDK\bin\java.exe ... false true Process finished with exit code 0
关系表达式与逻辑表达式运算
-
关系运算符的优先级高于逻辑运算符, 注意
逻辑非的优先级高于关系运算符public class Helloworld { public static void main(String[] args) { int a=12, b=19; boolean c,d; c=a>b||a<b; d=a>b&&a<b; System.out.println(c); System.out.println(d); } }D:\Java\JDK\bin\java.exe .... true false Process finished with exit code 0解析:
c=a>b||a<b
此表达式中, 运算符的优先级是, 关系运算符 ---> 逻辑运算符 ---> 赋值运算符
所以,先运算关系运算表达式, 其次逻辑表达式,最后赋值表达式
此处 a=12.b=19, a>b 的值是 false, a<b 的值是 true, false || true 的值为 true, 最后将 true 的值赋值给 boolean 型变量c, 所以最后 c 的值为 true
赋值运算符
-
=====此符号在java语言中不是等于的意思, 而是赋值, 在java中等于符号是 === ===
public class Helloworld { public static void main(String[] args) { int a=12, b=19,e=12; boolean c; c=a==e||a==b; System.out.println(c); } }D:\Java\JDK\bin\java.exe ... true Process finished with exit code 0
位运算符
-
二进制: 由 0 和 1 组成的一串数字
-
整型数据在内存中以 二进制 的方式存储, 比如: 一个 int 型变量在内存中占 4 个字节, 共32位
// int型数据 1 用二进制表示为 00000000 00000000 00000000 00000001
与运算符
-
& 一个and符号, 用于对两个整型数据 a 和 b 按位进行运算, 运算结果是一个整型数据 c.
-
运算法则: 如果a,b两个数据的对应位都是 1 ,则c的该位也是 1;否则为 0
a: 00000000 00000000 00000000 00000011 & b: 00000000 00000000 00000000 00000001 ----------------------------------------------- c: 00000000 00000000 00000000 00000001public class Helloworld { public static void main(String[] args) { int a=3, b=1,c; c=a&b; System.out.println(c); } } ------运行结果--------- 1
或运算符
-
'|' 用于对两个整型数据 a 和 b 按位进行运算, 运算结果是一个整型数据 c.
-
运算法则: 如果a,b两个数据的对应位都是 0 ,则c的该位也是 0;否则为 1
a: 00000000 00000000 00000000 00000011 | b: 00000000 00000000 00000000 00000001 ----------------------------------------------- c: 00000000 00000000 00000000 00000011public class Helloworld { public static void main(String[] args) { int a=3, b=1,c; c=a|b; System.out.println(c); } } -----运行结果----- 3
非运算符
-
'~' 用于对一个整型数据 a ,运算结果是一个整型数据 c.
-
运算法则: 如果a数据的对应位都是 0 ,则c的该位也是 1;否则为 0
~ a: 00000000 00000000 00000000 00000001 ----------------------------------------------- c: 11111111 11111111 11111111 11111110public class Helloworld { public static void main(String[] args) { int a=3, b=1,c; c=~a; System.out.println(c); } } ------运行结果------- -4
异或运算符
-
'^' 用于对两个整型数据 a 和 b 按位进行运算, 运算结果是一个整型数据 c.
-
运算法则: 如果a,b两个数据的对应位都是 0 ,则c的该位也是 0;否则为 1
a: 00000000 00000000 00000000 00000011 ^ b: 00000000 00000000 00000000 00000001 ----------------------------------------------- c: 00000000 00000000 00000000 00000010public class Helloworld { public static void main(String[] args) { int a=3, b=1,c; c=a^b; System.out.println(c); } } ------运行结果------- 2
语句
语句定义
- 在 java 中执行某项工作的'句子',一行可以有多条语句
语句的分类
-
方法调用语句
System.out.println("HelloWord"); -
表达式语句, 一个表达式代表一个语句,并在末尾加上英文格式的分号
x = 12; //赋值表达式 -
复合语句
{ sum = a+b; System.out.println(sum); } -
空语句, 一个分号也是一个语句
; -
控制语句
- 顺序语句
- 判断语句
- 循环语句
-
import语句 和 package语句
- 与 类 和 对象 有关
顺序语句
定义:
-
顺序结构是程序中最简单最基本的流程控制, 没有特定的语法结构, 按照代码的先后顺序, 依次执行, 程序中大多数的代码都是这样执行的
-
流程图
graph TD a(开始)-->b(语句A)-->d(语句B)-->c(...)-->e(结束) -
例
public class Helloworld { public static void main(String[] args) { System.out.printf("你"); System.out.printf("好"); System.out.printf("世界"); System.out.printf("!"); } } ---------执行结果--------------- D:\Java\JDK\bin\java.exe... 你好世界! Process finished with exit code 0
判断语句
定义:
- 满足特定的条件才执行语句
if语句
-
格式
if(表达式){ 若干语句; } -
例: 将变量a,b,c中的值按从大到小的顺序排列
-
普通形式书写
public class Helloworld { public static void main(String[] args) { int a=13,b=1,c=23,t; System.out.printf("原顺序: %d %d %d\n",a,b,c); if(a<b){ t=a; a=b; b=t; } if(a<c){ t=a; a=c; c=t; } if(b<c){ t=b; b=c; c=t; } System.out.printf("从大到小排序: %d %d %d\n",a,b,c); } } ---------执行结果-------------- 原顺序: 13 1 23 从大到小排序: 23 13 1 -
进阶版
import java.util.Scanner; public class Helloworld { public static void main(String[] args) { System.out.printf("请输入第一个数: "); Scanner put01 = new Scanner(System.in); int a = put01.nextInt(); System.out.printf("请输入第二个数: "); Scanner put02 = new Scanner(System.in); int b = put02.nextInt(); System.out.printf("请输入第三个数: "); Scanner put03 = new Scanner(System.in); int c = put03.nextInt(); int t; System.out.printf("原顺序: %d %d %d\n",a,b,c); if(a<b){ t=a;a=b;b=t; } if(a<c){ t=a;a=c;c=t; } if(b<c){ t=b;b=c;c=t; } System.out.printf("从大到小排序: %d %d %d\n",a,b,c); } } --------输入数据---------- 请输入第一个数: 23 请输入第二个数: 99 请输入第三个数: 45 --------执行结果---------- 原顺序: 23 99 45 从大到小排序: 99 45 23
if...else语句与if嵌套
-
格式
if(表达式){ 若干语句; } else{ 若干语句; } -
例
if(x>0) y=x+1; else y=2*x; -
利用语句表示分段函数
\[分段函数 \ \ \ y=\begin{cases} 2x，x>0\\ x^3+2, x=0\\ x^2+1, x<0\end{cases}\\ \]//利用 if语句 import java.util.Scanner; public class Helloworld { static double y; //成员变量[静态变量] public static void main(String[] args) { // double y; //局部变量 System.out.printf("请输入X的值:"); Scanner reader = new Scanner(System.in); double x = reader.nextDouble(); if(x>0) y=2*x; if(x==0) y=Math.cos(x)+2; if(x<0) y=x*x+1; System.out.println(y); } } --------编译结果-------- D:\Java\JDK\bin\java.exe ....... 请输入X的值:3 6.0 Process finished with exit code 0//利用 if ...else 语句 import java.util.Scanner; public class Helloworld { static double y; //成员变量[静态变量] public static void main(String[] args) { // double y; //局部变量 System.out.printf("请输入X的值:"); Scanner reader = new Scanner(System.in); double x = reader.nextDouble(); if(x>0){ y=2*x; } else if (x==0){ //if嵌套 y=Math.cos(x)+2; } else{ y=x*x+1; } System.out.println(y); } } --------编译结果-------- D:\Java\JDK\bin\java.exe ....... 请输入X的值:3 6.0 Process finished with exit code
switch语句
-
格式
switch(表达式){ //表达式的值可以是 byte,short,char,int型,权举类型,或String类型 case 常量值1: 若干语句; break; //break是可选项 case 常量值2: 若干语句; break; case 常量值3: 若干语句; break; .... case 常量值n: 若干语句; break; default: 若干语句; }注意:常量的值 与 表达式的类型是一致的break:跳出语句 -
例
\[输入一个成绩判断等级,90-100 优秀, 80-89良好, 60-79及格,0-59不及格 \] -
方法一:
利用if语句
import java.util.Scanner; public class Helloworld { public static void main(String[] args) { System.out.printf("请输入该学生的成绩:"); Scanner redear = new Scanner(System.in); int achievement = redear.nextInt(); if(achievement>=0&&achievement<=100){ if(achievement>=0&&achievement<=59) System.out.printf("不及及格"); if(achievement>=60&&achievement<=79) System.out.printf("及格"); if(achievement>=80&&achievement<=89) System.out.printf("良好"); if(achievement>=90&&achievement<100) System.out.printf("优秀"); if(achievement==100) System.out.printf("满分"); } else System.out.printf("超出范围请重新输入"); } } -------执行结果-------- D:\Java\JDK\bin\java.exe ...... 请输入该学生的成绩:23 不及格 Process finished with exit code 0 -
方法二
利用switch语句
import java.util.Scanner; public class Helloworld { public static void main(String[] args) { System.out.printf("请输入该学生的成绩:"); Scanner redear = new Scanner(System.in); int achievement = redear.nextInt(); if(achievement>=0&&achievement<=100) switch (achievement/10){ /*case 0: case 1: case 2: case 3: case 4: case 5: { System.out.printf("不及格"); break; } */ case 6: case 7: { System.out.printf("及格"); break; } case 8: { System.out.printf("良好"); break; } case 9: { System.out.printf("优秀"); break; } case 10: { System.out.printf("满分"); break; } default: System.out.printf("不及格"); } else System.out.printf("成绩超出范围,请重新输入"); } } -------执行结果-------- D:\Java\JDK\bin\java.exe ...... 请输入该学生的成绩:23 不及格 Process finished with exit code 0
循环语句
while循环
-
格式
while(表达式){ 若干语句; }流程图
s=>start: 开始 op01=>operation: 若干语句 cond=>condition: 表达式 end=>end: 结束 s->cond(yes)->op01(left)->cond cond(no)->end -
例
\[在控制台依次输入五个数并输出 \]import java.util.Scanner; public class Helloworld { public static void main(String[] args) { int i = 1; System.out.println("依次输入5个数:"); while (i<=5){ Scanner redear = new Scanner(System.in); int a = redear.nextInt(); System.out.println(a); i++; } } } --------执行结果--------- D:\Java\JDK\bin\java.exe ..... 依次输入5个数: 1 1 2 2 3 3 4 4 5 5 Process finished with exit code 0
do...while循环
-
格式
do{ 若干语句; } while(表达式);注意: 与while语句不同的是:此处的while语句后有分号 并且do...while的循环体至少循环一次
流程图
s=>start: 开始 op01=>operation: 若干语句 cond=>condition: 表达式 end=>end: 结束 s->op01->cond(yes,left)->op01 cond(no,bottom)->end -
例
\[依次输入3个数,并输出 \]import java.util.Scanner; public class Helloworld { public static void main(String[] args) { int i = 1; System.out.println("一次输入3个数:"); do { Scanner redear = new Scanner(System.in); int a = redear.nextInt(); System.out.println(a); i++; } while (i<=3); } } -----执行结果------ D:\Java\JDK\bin\java.exe ..... 一次输入3个数: 1 1 2 2 3 3 Process finished with exit code 0
for循环
-
格式
for(表达式1;表达式2;表达式3){ 若干语句; }注意: 表达式1 负责完成变量的初始化
表达式2 循环条件
表达式3 改变循环条件
流程图
st=>start: 开始 op01=>operation: 表达式1 op02=>operation: 循环体 op03=>operation: 表达式3 cond=>condition: 表达式2 e=>end: 结束框 st(right)->op01->cond->op02 cond(yes)->op02->op03(left)->cond cond(no)->e例:
\[1+2+3+4+...+100的值 \]public class Helloworld { public static void main(String[] args) { int i,sum=0; for (i=1;i<=100;i++){ sum+=i; } System.out.println(sum); } } ------执行结果------- D:\Java\JDK\bin\java.exe ..... 5050 Process finished with exit code 0
for循环练习
-
\[1. 输出1-100的所有数字,并按 10乘10的阵列排序 \]
import java.util.Scanner; public class Helloworld { public static void main(String[] args) { int i, j, a = 0; for (i = 1; i <= 100; i++) { System.out.printf("%3d", i); a++; if (a % 10 == 0) System.out.printf("\n"); } } } ------执行结果------ D:\Java\JDK\bin\java.exe ......... 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99100 Process finished with exit code 0
for循环的嵌套
-
格式
for(表达式1;表达式2;表达式3) for(表达式1;表达式2;表达式3){ 若干语句; } -
例
\[输出1-10的数,并按 10乘10的排列表示 \]import java.util.Scanner; public class Helloworld { public static void main(String[] args) { int i,j,a=0; for (i=1;i<=10;i++) for (j=1;j<=10;j++){ System.out.printf("%3d",i); a++; if(a%10==0) System.out.printf("\n"); } } } -------执行结果-------- D:\Java\JDK\bin\java.exe ......... 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3 3 3 4 4 4 4 4 4 4 4 4 4 5 5 5 5 5 5 5 5 5 5 6 6 6 6 6 6 6 6 6 6 7 7 7 7 7 7 7 7 7 7 8 8 8 8 8 8 8 8 8 8 9 9 9 9 9 9 9 9 9 9 10 10 10 10 10 10 10 10 10 10 Process finished with exit code 0
break 和 continue语句
-
在一个循环中,如果在循环50次的循环体中,在某次循环中执行了break语句,那么整个语句就结束;在某次循环中执行了continue语句,那么本次循环就结束,即不再执行本次循环中循环体中的continue语句后面的语句,而转入进行下一次循环
-
例:
\[计算1-10的奇数和 \]public class Helloworld { public static void main(String[] args) { int i,sum=0; for (i=1;i<=10;i++){ if (i%2==0){ continue; } sum+=i; } System.out.println(sum); } } ------执行结果------- D:\Java\JDK\bin\java.exe .... 25 Process finished with exit code 0\[求50以内的素数 \]import java.util.Scanner; public class Helloworld { public static void main(String[] args) { int i,j; for (i=2;i<=50;i++){ for(j=2;j<=i;j++){ if (i%j==0) break; } if (i==j) //j的值是 j++ 最后的值 System.out.printf("%3d",i); } } } -------执行结果------ D:\Java\JDK\bin\java.exe ... 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 Process finished with exit code 0
数组
声明数组
-
声明数组包括数组名,数组元素,数据类型
----- [一维数组] ----- //方法一 数组元素类型 数组名字[]; //方法二 数组元素类型[] 数组名字;----- [二维数组] ----- //方法一 数组元素类型 数组名字[][]; //方法二 数组元素类型[] []数组名字; -
例如
float boy[]; float[] boy; double cat[][]; double[] []cat;注意: Java与C/C++不同, Java不允许在声明数组中的方括号内指定数组元素的个数
int a[12]; int[12] a; //都会导致语法错误
创建数组
-
声明数组仅仅是给出了数组名字和元素的数据类型, 要想真正使用它,还必须为他分配内存空间,即创建数组
-
格式
数组名 = new 数组元素类型[数组元素个数]
boy = new float[4]; //new: 分配内存空间 为数组分配内存空间后, 数组boy获得4个用来存放float类型数据的内存空间,即4个float元素. 数组变量boy中存放着这些内存单元的首地址,该地址称为数组的引用 这样数组就可以通过索引操作这些内存单元,数组属于引用型变量,数组变量中存储存放着数组的首元素地址,通过数组名加索引使用数组的元素[注意: 索引是从 0 开始的]
声明数组和创建数组可以同时完成
char boy[] = new char[4];二维数组和一维数组一样, 在声明之后必须用new运算符分配内存空间
int number[][]; number = new int[3][4]; --------------------------或---------------------------------------- int number[][] = new int[3][4]; java采用 '数组的数组' 声明多维数组;一个多维数组是由多个一维数组组成的; 比如:
int number = new int[3][4]; ---------组成--------------- number[0][0],number[0][1],number[0][2],number[0][3] number[1][0],number[1][1],number[1][2],number[1][3] number[2][0],number[2][1],number[2][2],number[2][3]注意: 和C语言不同的是. Java允许使用int型变量的值指定数组元素的个数
int size=3; double number[] = new double[size];
使用数组
-
数组通过索引访问自己的元素
public class Helloworld { public static void main(String[] args) { int a[] = new int[2]; a[0] = 3; //给数组元赋值 System.out.println(a[0]); //输出数组元素 a[1] = 4; System.out.println(a[1]); a[2] = 5; System.out.println(a[2]); } } --------执行结果-------- D:\Java\JDK\bin\java.exe ........ 3 4 Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 2 out of bounds for length 2 at Helloworld.main(Helloworld.java:8) [....索引2超出长度2的界限.....在Helloworld.main（Helloworld.java:8）] Process finished with exit code 1
length的使用
-
数组元素的个数称为数组元素的长度
对于一维数组 "数组名.length"的值就是数组中元素的个数
对于二维数组 "数组名.length"的值是它含一维数组的个数
public class Helloworld { public static void main(String[] args) { float a[] = new float[13]; double b[][] = new double[3][4]; System.out.println(a.length); //一维数组元素个数 System.out.println(b.length); //二维数组中一维数组个数 } } -------执行结果------- D:\Java\JDK\bin\java.exe ...... 13 3 Process finished with exit code 0
数组初始化
-
创建数组后,系统会给每个元素一个默认值, 在声明数组的同时也可以给数组元素一个初值
一维数组初始化
public class Helloworld { public static void main(String[] args) { int a[] = {1,2,3,4}; //相当于 int a[] = new int[4]; System.out.println(a[0]); System.out.println(a[1]); System.out.println(a[2]); System.out.println(a[3]); } } --------执行结果-------- D:\Java\JDK\bin\java.exe ...... 1 2 3 4 Process finished with exit code 0public class Helloworld { public static void main(String[] args) { int i; int a[] = {1,2,3,4}; //相当于 int a[] = new int[4]; for (i=0;i<4;i++) System.out.println(a[i]); } } --------执行结果-------- D:\Java\JDK\bin\java.exe ...... 1 2 3 4 Process finished with exit code 0\[输入4个数分别存入数组元素中, 再分别输出4个元素 \]import java.util.Scanner; public class Helloworld { public static void main(String[] args) { int i, a[] = {1,2,3,4}; //相当于 int a[] = new int[4]; System.out.println("请输入四个数:"); for (i=0;i<4;i++){ Scanner redaer = new Scanner(System.in); //输入四个数分别存入数组元素中 a[i] = redaer.nextInt(); } System.out.println("这四个数是:"); for (i=0;i<4;i++){ System.out.println(a[i]); //输出元素 } } } --------执行结果-------- D:\Java\JDK\bin\java.exe ...... 请输入四个数: 12 32 45 55 这四个数是: 12 32 45 55 Process finished with exit code 0二维数组初始化
public class Helloworld { public static void main(String[] args) { int a[][] = {{2,4},{6,8},{10,12}}; //相当于 int a[][] = new int[2][2] System.out.println(a[0][0]); System.out.println(a[0][1]); System.out.println(a[1][0]); System.out.println(a[1][1]); System.out.println(a[2][0]); System.out.println(a[2][1]); } } ------执行结果 ------ D:\Java\JDK\bin\java.exe ...... 2 4 6 8 10 12 Process finished with exit code 0public class Helloworld { public static void main(String[] args) { int i,j,a[][] = {{2,4},{6,8},{10,12}}; //相当于 int a[][] = new int[2][2] for (i=0;i<=2;i++) for (j=0;j<=1;j++) System.out.println(a[i][j]); } } ---------执行结果--------- D:\Java\JDK\bin\java.exe ....... 2 4 6 8 10 12 Process finished with exit code 0\[输入六个数分别存入二维数组中, 并输出六个数 \]import java.util.Scanner; public class Helloworld { public static void main(String[] args) { int i,j,a[][] = new int[3][2]; System.out.println("输入六个数:"); for (i=0;i<=2;i++) for (j=0;j<=1;j++){ Scanner redaer = new Scanner(System.in); a[i][j] = redaer.nextInt(); } System.out.println("这六个数是:"); for (i=0;i<=2;i++) for (j=0;j<=1;j++) System.out.printf("%3d",a[i][j]); } } -------- 执行结果 -------- D:\Java\JDK\bin\java.exe.......... 输入六个数: 23 43 54 65 76 86 这六个数是: 23 43 54 65 76 86 Process finished with exit code 0
数组的表示格式
-
利用 Arrays类调用
import java.util.Arrays; public class Helloworld { public static void main(String[] args) { int i,a[] = {1,2,3,4,5,6}; System.out.println(Arrays.toString(a)); for (i=0;i<=5;i++){ System.out.printf("%2d",a[i]); } } } -------执行结果--------- D:\Java\JDK\bin\java.exe ...... [1, 2, 3, 4, 5, 6] 1 2 3 4 5 6 Process finished with exit code 0
数组的复制
数组的索引
-
数组属于引用型变量, 因此,两个相同类型的数组如果具有相同的引用,他们就有完全相同的元素
import java.util.Arrays; public class Helloworld { public static void main(String[] args) { int a[] = {1,2,3,4},b[] = {3,6,9,4},i; System.out.println(a); //输出数组地址 System.out.println(b); for (i=0;i<=3;i++){ // System.out.println(a[i]); System.out.printf("%3d",a[i]); } System.out.printf("\n"); a=b; //将b的地址赋予 a System.out.println(a); for (i=0;i<=3;i++){ // System.out.println(a[i]); System.out.printf("%3d",a[i]); } } } -------执行结果--------- D:\Java\JDK\bin\java.exe ....... [I@5594a1b5 [I@6a5fc7f7 1 2 3 4 [I@6a5fc7f7 3 6 9 4 Process finished with exit code 0
类与对象
类
- 类是组成Java程序的基本要素, 一个Java程序是由若干个类构成,这些类既可以在一个源文件中,也可以分布在若干个源文件中
类的定义
-
类声明 和 类体
class 类名{ 类体类容 }
类的声明
-
例
class China { ... } class 中国 { ... }class China 和 class 中国 被称为类的声明, China 和 中国 分别是类名,类的名字要符合
标识符的规定[即: 由字母,下画线,数字 和 美元符号, 且第一个字符不能是数字]注意:如果类名使用拉丁字母,那么首字母必须大写, 且需要见名知意
类体
-
类声明之后的一对大括号以及它们之间的内容称作类体
类的目的是为了抽象出一类事物共有的属性和行为能力, 抽象的关键是: 数据以及在数据上所进行的操作
类体的构成:
- 变量声明: 用来存储属性的值(体现对象的属性)
- 方法定义: 方法可以对类中声明的变量进行操作,即给出算法(体现对象所具有的行为能力)
//求梯形面积 class 梯形 { float 上底,下底,高,面积; //声明变量 float 梯形面积(){ //方法定义 面积 = (上底 + 下底)*高/2.0f; return 面积; } }
变量
成员变量
-
声明部分的变量
成员变量在整个类中的所有方法中都有效, 其有效性与成员变量在类中的位置无关
class China{ int a,b; //成员变量 void f(){ double c; //局部变量 } int d; //成员变量 }注意:成员变量又分为实例变量和类变量- 在声明变量时, 用关键字static修饰的变量称类变量[也称: static变量,静态变量], 否则就是实例变量
class Dog{ float x; //实例变量 static int y; //类变量 }
局部变量
-
在方法中声明的变量和方法的参数
局部变量只有在声明它的方法内有效
如果局部变量声明在一个复合语句中, 那么该局部变量只在复合语句中有效
如果局部变量声明在一个循环语句中, 那么该局部变量只在循环语句中有效
class 梯形 { float a,b,c; //成员变量 float sum(){ if (a>10){ int z=100; z=2+a-z //局部变量 } for (int i=1;i<=30;i++){ b=b+c; } a=b=c; //合法, a,b,c有效 z=i; //不合法, z 和 i 已失效 } }
方法
方法定义
-
声明类型 方法名(){ 方法体内容 }
方法声明
-
最基本的方法声明包括方法名和方法的返回类型
float area(){ ...; return; }如果一个方法不需要返回数据时,返回类型必须是void.
注意:方法名如果用拉丁字母表示,首字母小写, 多个单词时,从第二个单词开始首字母均大写float areaChinaBeijing(){ ...; return; }
方法体
-
方法体中包括: 局部变量 和 Java 语句
int getSum(){ int sum=0; //声明局部变量 for(int i=1;i<=n;i++){ //for循环 sum = sum + i; } return sum; //返回值 }
方法重载
-
方法重载的意思: 一个类中可以有多个方法具有相同的名字,但这些方法的参数必须不同,即或者是参数的个数不同,或者是参数的类型不同
class Example { float getExample(float r){ return 3.14f*r*r; //圆的面积 } double getExample(float x,int y){ return x*y; //矩形面积 } float getExample(int x,float y){ return x*y; //矩形面积 } double getExample(float x,float y,float z){ return x*y*z; //长方体体积 } }功能多性: 可以向功能传递不同的消息,以便让对象根据相应的消息来产生相应的行为
对象的功能: 通过类中的方法来体现
构造方法
-
构造方法是一种特殊的方法; 它的名字
必须与它所在类的名字完全相同,而且没有类型, 构造方法也可以重载class 梯形{ float 上底,下底,高; //定义变量 梯形(){ //构造方法 上底 = 60; 下底 = 100; 高 = 20; } 梯形(float x,int y,float z){ //构造方法 上底 = x; 下底 = y; 高 = h; } }这里略讲, 后续会详细介绍
类方法和实例方法
-
成员变量可以分为实例变量和类变量; 同样,类中的方法也可以分为实例方法和类方法
方法类型前加关键字 static 的为类方法, 否则为实例方法 [后续会详细介绍]
class A{ int max(float x,float y){ //实例方法 ... } static float z(){ //类方法 ... } static void speak(String s){ //类方法 ... } }
注意事项
-
对成员变量的操作只能放在方法中, 方法可以对成员变量和该方法体中声明的局部变量进行操作
注意:声明类的成员变量时可以同时赋予初值class A{ int a=12; float b=1.3f; }但是不可以这样做
class A{ int a; float b; a=12; //非法, 这是复制语句(语句只能出现在方法体中), 不是变量的声明 b=3.2f; //非法 }这是因为类体的内容是由成员变量的声明和方法的定义两部分组成
class A{ int a; float b; void f(){ int x,y; x=2; y=3; a=12; b=3.2f; } } -
实例方法既能对类变量操作 也能对实例变量操作, 而类方法只能对类变量进行操作
class A{ int a; //实例变量 static int b; //类变量 void f(int x,int y){ //实例方法 a=x; //操作实例变量 b=y; //操作类变量 } static void g(int z){ //类方法 b=23; //操作类变量 a=z; //非法, 不能操作实例变量 } } -
一个类中的方法可以互相调用,, 实例方法可以调用该类中的其他方法; 类中的类方法只能调用该类的类方法
class A{ float a,b; void sum(float x,float y){ //这是一个实例方法 a = max(x,y); //合法[调用类方法] b = min(x,y); //合法[调用实例方法] System.out.println(a+b); } static float max(float x,float y){ //类方法 return x>y?x:y; } float min(float x,float y){ //实例方法 return x<y?x:y; } }
对象
简介
-
类是面向对象语言中最重要的一种数据据类型,可以用类来声明变量. 在面向对象语言中,用类声明的变量被称为对象. 和基本数据不同,在用类声明对象后, 还必须创建对象, 即为声明的对象分配所拥有的变量(确定对象所具有的属性),当使用一个类创建一个对象时,也称给出了这个类的一个实例.
简而言之: 类是创建对象的模板,没有类就没有对象
构造方法
- 作用: 当程序用类创建对象时需使用它的构造方法
默认的构造方法
-
如果类中没有编写构造方法,系统会默认该类只有一个构造方法,该默认的构造方法是无参数的, 且方法体中没有语句
class P{ int x,y; }
自定义构造方法
-
如果类中定义了一个或多个构造方法,那么Java不提供默认的构造方法
class P{ int x,y; P(){ x=1; y=1; } P(int a,int b){ x=a; y=b; } }
构造方法没有类型
-
需要特别注意的是, 构造方法没有类型
class P{ int x,y; //是构造方法 P(){ x=1; y=1; } void P(int a,int b){ //不是构造方法 [因为有类型] x=a; y=b; } int P(){ //不是构造方法 return 12; } }
创建对象
创建一个对象包括对象的声明和为对象分配变量
对象的声明
-
一般格式
类的名字 对象名字; -
例如
public class Helloworld { Helloworld c; //创建一个c对象 }
为声明的对象分配变量
-
使用
new运算符 和类的构造方法为声明的对象分配变量, 即创建对象. 如果类中没有构造方法,系统会调用默认的构造方法, 默认的构造方法是无参数的,且方法体中没有语class Java{ //声明一个Java类 float height,weight; //在Java类中声明变量 String head,ear; void speak(String s){ System.out.println(s); } } public class Helloworld{ public static void main(String[] args) { Java zhubajie,sunwukong; //声明对象 zhubajie = new Java(); //为对象分配变量(使用 new 和 默认的构造方法) sunwukong = new Java(); } }
使用对象
-
类的目的是创建具有属性和行为的对象. 对象不仅可以操作自己的变量改变状态,而且可以调用
类中的方法产生一定的行为通过使用运算符 "
.",对象可以实现对自己的变量的访问和方法调用
-
对象操作自己的变量
格式 对象.变量; -
对象调用类中的方法
格式 对象.方法;
浙公网安备 33010602011771号