java基础，

来源： javaer 分享于 2022-06-15 点击 324 次点评：140

java基础，

JDK ：Java development kit （Java开发工具包）是太阳微系统针对Java开发人员发布的免费软件开发工具包(SDK，Software development kit)。JDK 是整个Java的核心，包括了Java运行环境、Java工具和Java基础类库。2006年太阳微系统宣布将发布基于GPL协议的开源JDK，使JDK成为自由软件。

企业级JavaBean（Enterprise JavaBeanEJB）是一个用来构筑企业级应用的服务器端可被管理组件。EJB规范的目的在于为企业及应用开发人员实现后台业务提供一个标准方式，从而解决一些此前总是在作业过程中总是重复发生的问题。EJB最早于1997年由IBM提出，旋即被太阳微系统采用并形成标准（EJB 1.0 和EJB 1.1）。其特点包括网络服务支持和核心开发工具(SDK)。在J2EE里，分别是会话Bean（Session Bean），实体Bean（Entity Bean）和消息驱动Bean（MessageDriven Bean）。EJB以一个标准方式自动处理了诸如数据持久化，事务集成，安全对策等不同应用的共有问题，使得软件开发人员可以专注于程序的特定需求而不再饱受那些非业务元素的困扰。

JRE：Java runtime environment(Java 运行环境运行JAVA程序所必须的环境的集合，包含JVM标准实现及Java核心类库。JDK包含JRE，包含JVM

java 1995 sun推出 后被oracle收购
java SE （标准版本）：基础核心部门 —— 面向对象 API JVM。。。
java EE （企业级版）：企业应用开发——JSP EJB webservice 工作流。。。
java ME（嵌入式开发）：手机嵌入——移动设备、游戏、通信。。。

JSP（全称JavaServerPages）是由Sun Microsystems公司倡导和许多公司参与共同创建的一种使软件开发者可以响应客户端请求，而动态生成HTML、XML或其他格式文档的Web网页的技术标准。JSP技术是以Java语言作为脚本语言的，JSP网页为整个服务器端的Java库单元提供了一个接口来服务于HTTP的应用程序。用JSP开发的Web应用是跨平台的，既能在Linux下运行，也能在其他操作系统上运行。

JVM是JavaVirtualMachine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java语言的一个非常重要的特点就是与平台的无关性。而使用Java虚拟机是实现这一特点的关键。一般的高级语言如果要在不同的平台上运行，至少需要编译成不同的目标代码。而引入Java语言虚拟机后，Java语言在不同平台上运行时不需要重新编译。Java语言使用Java虚拟机屏蔽了与具体平台相关的信息，使得Java语言编译程序只需生成在Java虚拟机上运行的目标代码（字节码），就可以在多种平台上不加修改地运行。Java虚拟机在执行字节码时，把字节码解释成具体平台上的机器指令执行。这就是Java的能够“一次编译，到处运行”的原因。

API（Application Programming Interface,应用程序编程接口）是一些预先定义的函数，目的是提供应用程序与开发人员基于某软件或硬件得以访问一组例程的能力，而又无需访问源码，或理解内部工作机制的细节。API与系统调用的区别：系统调用代码都处于内核态，API是操作系统提供的一组函数，通常以库的形式存在，供用户调用，所以，API代码可能是完全是用户空间代码，也有的API调用了系统调用。

源文件（以.java）-编译器-字节码文件（.class）-解释器【JVM中已包括了解释器】

第一步：安装JDK下载地址：http://www.oracle.com/technetwork/java/javase/downloads
第二步：配置环境变量
1、JAVA_HOME（配置JDK安装路径）2、Path（配置JDK命令文件的位置）3、CLASSPATH(配置类库文件的位置

记事本编写java运行java文件：E：——切换路径dir查看文件是否存在javac.xxxx.java编译java.xxxx运行

IDE:integrated development environment  将程序开发环境和程序调试环境集合在一起，提高开发效率；

1.创建java项目-Java project2.创建程序包-src-package3.编写java源程序-class4.运行java程序

MyEclipse对于Eclipse的扩展，用于开发java javaEE的Eclipse的插件组合
下载地址 http://www.my-eclipse.cn/
1.创建工程2.创建包3.创建源代码文件（2-3可用一步操作）4.运行程序
myeclipse的确是自带了jdk和tomcat插件，但是没有独立的好用的，如果你要改自己的jdk，可以点击window-preferens-myeclipse-Servers-Tomcat-JDK，点击add，选择自己安装jdk目录文件夹，然后你想换成下载的tomcat，比如我下载是阿帕奇的tomcat7，所以点击tomcat 7.x，点击Enable，第一个Browse，选择自己安装的tomcat目录文件夹。...

程序移植：

空白右击，找到 Import...(导入) 选择 General--Existing Projects into Workspace 选择下一步-- 选择 Browse....(找到要导入的项目)；

导出：右击项目选择PropertiesLocation打开文件所在位置复制文件到U盘或其他盘：

经验技巧总结：多练，多问，自己调试，增加动手能力，复习，总结

guanjianz

标识符就是用于给 Java 程序中变量、类、方法等命名的符号。
使用标识符时，需要遵守几条规则：

 1.  标识符可以由字母、数字、下划线（_）、美元符（$）组成，但不能包含 @、%、空格等其它特殊字符，不能以数字开头。譬如：123name 就是不合法滴
 2.  标识符不能是 Java 关键字和保留字（ Java 预留的关键字，以后的升级版本中有可能作为关键字），但可以包含关键字和保留字。如：不可以使用 void 作为标识符，但是 Myvoid 可以
 3.  标识符是严格区分大小写的。 
 4.  标识符的命名最好能反映出其作用，做到见名知意

在 Java 中，我们通过三个元素描述变量：变量类型、变量名以及变量值。

变量类型 变量名=变量值（"变量值"）;

如果我们把变量比作是酒店的房间，要存储的数据就好比要住宿的客人，我们可以根据客人的要求安排其入住“标准间”或者是“总统套房”，并且可以根据房间名字快速查找到入住客人的信息。同理，在 Java 程序中，我们也可以根据所需要保存的数据的格式，将其保存在指定类型的变量空间中，并且通过变量名快速定位！Java 中的标点符号是英文的。譬如语句结束的分号，是英文符号的分号

如果是String 赋值 是默认字符串，“+”代表连接；
如果是类似Integer 赋值 默认整型时候，“+”代表加号；
massion_特殊情况：如果是Integer a = 1; Integer b = 2;  那 “a”+b 输出结果是"a2"

在给变量起名字时，必须符合一定的规则:
1、变量名由多单词组成时，第一个单词的首字母小写，其后单词的首字母大写，俗称骆驼式命名法（也称驼峰命名法），如 myAge
2、变量命名时，尽量简短且能清楚的表达变量的作用，做到见名知意。如：定义变量名 stuName 保存“学生姓名”信息
PS： Java 变量名的长度没有限制，但 Java 语言是区分大小写的，所以 price 和 Price 是两个完全不同的变量哦！

java 变量名命名 首字母：字母、下划线、美元符号 首字母不允许是数字 其余部分可以是数字

数据类型

java 中变量名要先声明后使用。
变量使用时可以声明变量的同时进行初始化，也可以先声明后赋值。
变量中每次只能赋一个值，但可以多次修改。
main方法中定义的变量必须先赋值然后才能输出。
开发中不建议使用中文定义变量名，容易产生安全隐患

java自动类型转换
1. 目标类型能与源类型兼容如double型兼容 int 型，但是 char 型不能兼容 int 型
2. 目标类型大于源类型如 double 类型长度为8字节，int 类型为4字节，因此 double 类型的变量里直接可以存放 int 类型数据，反过来不可以
强制类型转换
语法：（数据类型）数值
强制类型转换数值上并未进行四舍五入，而是直接将小数位截断。可能会造成数据的丢失。

常量可以理解为一种特殊的变量，他在程序运行过程中是不允许改变的。
final String LOVE = "apple";
常量名一般用大写字符

文档注释/** */
多行注释/* */
单行注释//
@author 标明开发该类模块的作者
@version 标明该类模块的版本
@see 参考转向，也就是相关主题
@param 对方法中某参数的说明
@return 对方法返回值的说明
@exception 对方法可能抛出的异常进行说明

常用的运算符：
算术运算符如 + - * / % ++ --
赋值运算符如 = += -= *= /= %=
比较运算符如 > < >= <= == !=
逻辑运算符如 && || ! ^
条件运算符（ ? : ）也称为 “三元运算符” 语法形式：布尔表达式? 表达式1：表达式2 运算过程：如果布尔表达式的值为 true ，则返回表达式1 的值，否则返回表达式2 的值
自增和自减运算符只能用于操作变量，不能直接用于操作数值或常量
前置++是将自身加1的值赋值给新变量，同时自身也加1；②后置++是将自身的值赋给新变量，然后才自身加1.
> 、 < 、 >= 、 <= 只支持左右两边操作数是数值类型 == 、 != 两边的操作数既可以是数值类型，也可以是引用类型
1、&&(与)：要求所有人都投票同意，才能通过某议题
2、||（或）：只要求一个人投票同意就可以通过某议题
3、！（非）：某人原本投票同意，通过非运算符，可以使其投票无效
4、^(异或)：有且只能有一个人投票同意，才可以通过某议题
当使用逻辑运算符时，我们会遇到一种很有趣的“短路”现象譬如：( one > two ) && ( one < three ) 中，如果能确定左边 one > two 运行结果为 false , 则系统就认为已经没有必要执行右侧的 one < three 啦。
同理，在( one > two ) || ( one < three ) 中，如果能确定左边表达式的运行结果为 true , 则系统也同样会认为已经没有必要再进行右侧的 one < three 的执行啦！

条件语句
如果 if 条件成立时的执行语句只有一条，是可以省略大括号滴！但如果执行语句有多条，那么大括号就是不可或缺
“需要先判断条件，条件满足后才执行的情况”，就可以使用 if 条件语句实现。
例：
if(条件){
条件成立时执行的代码
}
“当条件成立时执行某个代码，如果不成立则执行另一个”使用if……else。
例：if(条件的布尔表达式){
成立时执行的代码
}else{
不成立时执行的代码
}
“有多个条件时”使用多重if语句。
例：if(条件1){
满足条件1时执行的代码
}else if(条件2){
满足条件2时执行的代码
}else if(条件3){
满足条件3时执行的代码
}else{
以上条件都不满足时执行的代码
}
“大条件成立时才判断执行多个小条件”使用嵌套 if 语句。
例：
if(条件1){
if(条件2){
代码块1
}else{
代码块2
}
}else{
代码块3
}

“当需要对选项进行等值判断时”使用 switch 语句。
例：switch(表达式1){
case 值1:
满足值1时执行的代码
break;
case 值2:
满足值2时执行的代码
break;
case 值3:
满足值3时执行的代码
break;
default:
默认的代码
}
1、 switch 后面小括号中表达式的值必须是java 1.6(包括)以前，只是支持等价成int 基本类型的数据:byte ,short,char,int(其他的都不可以）；整型或字符型、枚举型表达式，jkd1.7以后可以是字符串
2、 case 后面的值可以是常量数值，如 1、2；也可以是一个常量表达式，如 2+2 ；但不能是变量或带有变量的表达式，如 a * 2
3、 case 匹配后，执行匹配块里的程序代码，如果没有遇见 break 会继续执行下一个的 case 块的内容，直到遇到 break 语句或者 switch 语句块结束
4、表达相同意思的case语句可以合并例：
case 1:
case 2:
System.out.println("奖励ipad 2一台");
case语句按编写顺序执行，不按数字顺序执行；default 块可以出现在任意位置，优先执行case语句

Java 常用的 3 种循环： while 、 do...while 、 for

while循环
while(判断条件){
循环操作内容
}
执行过程：
<1>判断 while 后面的条件是否成立( true / false )
<2>当条件成立时，执行循环内的操作代码，然后重复执行< 1 >、< 2 >，直到循环条件不成立为止
特点：先判断，后执行
do...while 循环
do{
循环操作
}while(判断条件);
执行过程：
<1>、先执行一遍循环操作，然后判断循环条件是否成立
<2>、如果条件成立，继续执行< 1 > 、< 2 >，直到循环条件不成立为止
特点：先执行，后判断
由此可见，do...while 语句保证循环至少被执行一次！

for 循环。
for(循环变量初始化;循环条件;循环变量变化){
循环操作
}
执行过程：
<1>、执行循环变量初始化部分，设置循环的初始状态，此部分在整个循环中只执行一次
<2>、进行循环条件的判断，如果条件为 true ，则执行循环体内代码；如果为 false ，则直接退出循环
<3>、执行循环变量变化部分，改变循环变量的值，以便进行下一次条件判断
<4>、依次重新执行< 2 >、< 3 >、< 4 >，直到退出循环
特点：相比 while 和 do...while 语句结构更加简洁易读
附代码：
int sum = 0; // 保存不能被3整除的数之和

// 循环变量 i 初始值为 1 ,每执行一次对变量加 1，只要小于等于 100 就重复执行循环
for (int i = 1; i<=100 ; i++ ) {

// 变量 i 与 3 进行求模（取余），如果不等于 0 ，则表示不能被 3 整除
if (i % 3 != 0) {
sum = sum + i; // 累加求和
}
}

System.out.println("1到100之间不能被3整除的数之和为：" + sum);
}

break和continue的区别：break是直接跳出循环，continue是跳过此次循环，循环仍进行。
附代码：
// 保存累加值
int sum = 0;

// 从1循环到10
for (int i = 1; i <= 10; i++) {

// 每次循环时累加求和
sum = sum + i;

// 判断累加值是否大于20，如果满足条件则退出循环
if ( sum>20 ) {

System.out.print("当前的累加值为:" + sum);

break;//退出循环

}
}

int sum = 0; // 保存累加值
for (int i = 1; i <= 10; i++) {
// 如果i为奇数,结束本次循环，进行下一次循环
if (i%2!=0 ) {
continue;
}
sum = sum + i;
}
System.out.print("1到10之间的所有偶数的和为：" + sum);

// 外层循环控制行数
for (int i = 1; i<=4;i++ ) {

// 内层循环控制每行的*号数
// 内层循环变量的最大值和外层循环变量的值相等
for (int j = 1; j<=i;j++ ) {

System.out.print("*");
}

判断一个数（小于10位）的位数。
输入999，则输出 “它是个3位的数！”
if (num >= 0 && num<=999999999){
while(num != 0){
count++;
num/=10;
}
System.out.println("它是个"+ count+"位的数！");
} else{
System.out.println("输入有误！");
}

// 变量保存成绩
int score = 53;
// 变量保存加分次数
int count = 0;
//打印输出加分前成绩
System.out.println("加分前成绩："+score);
// 只要成绩小于60，就循环执行加分操作，并统计加分次数
for(;score<60;score++,count++){
// count++;
if(score>=60){
break;
}
}
//打印输出加分后成绩，以及加分次数
System.out.println("加分后成绩"+score);
System.out.println("共加了"+count+"次！");



记住：eslip软件用快捷键方式可以省略一些长输入，
如：用输入：syso+ alt键再加/ 就可以实现System.out.println(); 的输入
public static void main (String[] args) 的快捷键是main+alt+/

关于 Java 数组的 12 个最佳方法
1. 声明一个数组
String[] aArray = new String[5];
String[] bArray = {"a","b","c", "d", "e"};
String[] cArray = new String[]{"a","b","c","d","e"};
2. 输出一个数组
int[] intArray = { 1, 2, 3, 4, 5 };
String intArrayString = Arrays.toString(intArray);
// print directly will print reference value
System.out.println(intArray);
// [I@7150bd4d

System.out.println(intArrayString);
// [1, 2, 3, 4, 5]

3. 从一个数组创建数组列表
String[] stringArray = { "a", "b", "c", "d", "e" };
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));
System.out.println(arrayList);
// [a, b, c, d, e]
4. 检查一个数组是否包含某个值
String[] stringArray = { "a", "b", "c", "d", "e" };
boolean b = Arrays.asList(stringArray).contains("a");
System.out.println(b);
// true
5. 连接两个数组
int[] intArray = { 1, 2, 3, 4, 5 };
int[] intArray2 = { 6, 7, 8, 9, 10 };
// Apache Commons Lang library
int[] combinedIntArray = ArrayUtils.addAll(intArray, intArray2);

6. 声明一个内联数组（Array inline）
method(new String[]{"a", "b", "c", "d", "e"});

7. 把提供的数组元素放入一个字符串
// containing the provided list of elements
// Apache common lang
String j = StringUtils.join(new String[] { "a", "b", "c" }, ", ");
System.out.println(j);
// a, b, c
8. 将一个数组列表转换为数组
String[] stringArray = { "a", "b", "c", "d", "e" };
ArrayList<String> arrayList = new ArrayList<String>(Arrays.asList(stringArray));
String[] stringArr = new String[arrayList.size()];
arrayList.toArray(stringArr);
for (String s : stringArr)
System.out.println(s);

9. 将一个数组转换为集（set）
Set<String> set = new HashSet<String>(Arrays.asList(stringArray));
System.out.println(set);
//[d, e, b, c, a]

10. 逆向一个数组
int[] intArray = { 1, 2, 3, 4, 5 };
ArrayUtils.reverse(intArray);
System.out.println(Arrays.toString(intArray));
//[5, 4, 3, 2, 1]

11. 移除数组中的元素
int[] intArray = { 1, 2, 3, 4, 5 };
int[] removed = ArrayUtils.removeElement(intArray, 3);//create a new array
System.out.println(Arrays.toString(removed));

12. 将整数转换为字节数组
byte[] bytes = ByteBuffer.allocate(4).putInt(8).array();
for (byte t : bytes) {
System.out.format("0x%x ", t);
}

在详细说下上述内容：
1、声明数组
语法：数据类型[] 数组名；或者：数据类型数组名[]；
例：int（数据类型）[] scores（数组名）;int（数据类型） scores（数组名）[]
声明数组的方法和生命变量的方法很像只是在数据类型或者数据名的后面加上了[]
2、分配空间
语法：数组名 = new 数据类型 [数组长度];
例：scores = new int [5];
简单地说，就是指定数组中最多可存储多少个元素.
3、赋值
分配空间后就可以向数组中放数据了，数组中元素都是通过下标来访问的
scores[0] = 89;
4、处理数组中数据
int[] scores = {1,2,3,4};（创建一个长度为4的整形数组）等价于int[] scores=new int[]{1,2,3,4}

数组名.length 用于获取数组的长度

// 定义一个整型数组，并赋初值
int[] nums = new int[] { 61, 23, 4, 74, 13, 148, 20 };
int max = nums[0]; // 假定最大值为数组中的第一个元素
int min = nums[0]; // 假定最小值为数组中的第一个元素
double sum = 0;// 累加值
double avg = 0;// 平均值
for (int i = 0; i < nums.length; i++) { // 循环遍历数组中的元素
// 如果当前值大于max，则替换max的值
if(nums[i]>max)
{
max=nums[i];
}
// 如果当前值小于min，则替换min的值
if(nums[i]<min)
{
min=nums[i];
}
// 累加求和
sum=sum+nums[i];
}
avg=sum/nums.length;
// 求平均值
System.out.println("数组中的最大值：" + max);
System.out.println("数组中的最小值：" + min);
System.out.println("数组中的平均值：" + avg);
}

语法： Arrays.sort(数组名);
可以使用 sort( ) 方法实现对数组的排序，只要将数组名放在 sort( ) 方法的括号中，就可以完成对该数组的排序（按升序排列）
语法： Arrays.toString(数组名);
可以使用 toString( ) 方法将一个数组转换成字符串，该方法按顺序把多个数组元素连接在一起，多个元素之间使用逗号和空格隔开
例如结果例子：输出数组nums中的元素：[25，7，126，53，14，86] [game, movie, sports]
使用 foreach 操作数组 foreach 并不是 Java 中的关键字，是 for 语句的特殊简化版本，在遍历数组、集合时， foreach 更简单便捷。
for(元素类型元素变量（自定义的名称）：遍历对象){
执行的代码
}
使用 foreach 操作数组的效果和for的效果时一样的但是代码简洁

二维数组：
（1）声明数组并分配空间：数据类型[][]=new 数据类型[行的个数][列的个数];
数组类型[][] 数组名;
数组名=new 数据类型[行的个数][列的个数];
（2）赋值:数组名[行的索引][列的索引]=值;
也可以声明数组的同时为其赋值：数据类型[][] 数组名={{123},{456}};
（3）处理数组：
需要了解的：在定义二维数组时也可以只指定行的个数，然后再为每一行分别指定列的个数。如果每行的列数不同，则创建的是不规则的二维数组

附代码：
// 定义两行三列的二维数组并赋值
String[][] names={{"tom","jack","mike"},{"zhangsan","lisi","wangwu"}};

// 通过二重循环输出二维数组中元素的值
//names.length行数
for (int i = 0; i < names.length ; i++) {
//names[i].length列数
for (int j = 0; j < names[i].length; j++) {

System.out.println( names[i][j]);
}

System.out.println();
}

定义一个方法
所谓方法，就是用来解决一类问题的代码的有序组合，是一个功能模块。
语法：访问修饰符返回值类型方法名（参数列表）{
方法体
}
其中：
1、访问修饰符：方法允许被访问的权限范围，可以是 public、protected、private 甚至可以省略，其中 public 表示该方法可以被其他任何代码调用
2、返回值类型：方法返回值的类型，如果方法不返回任何值，则返回值类型指定为 void ；如果方法具有返回值，则需要指定返回值的类型，
并且在方法体中使用 return 语句返回值
3、方法名：定义的方法的名字，必须使用合法的标识符
4、参数列表：传递给方法的参数列表，参数可以有多个，多个参数间以逗号隔开，每个参数由参数类型和参数名组成，以空格隔开
根据方法是否带参、是否带返回值，可将方法分为四类：
无参无返回值方法无参带返回值方法带参无返回值方法带参带返回值方法

java中无参无返回值方法的使用
如果方法不包含参数，且没有返回值称为无参无返回值的方法。
方法的使用：
第一定义方法
1、方法体放在一对大括号中，实现特定的操作
2、方法名主要在调用这个方法时使用，需要注意命名的规范，一般采用第一个单词首字母小写，其它单词首字母大写的形式
第二调用方法
当需要调用方法执行某个操作时，可以先创建类的对象，然后通过对象名.方法名();来实现

1、如果方法的返回类型为 void ，则方法中不能使用 return 返回值！
2、方法的返回值最多只能有一个，不能返回多个值
3、方法返回值的类型必须兼容，例如，如果返回值类型为 int ，则不能返回 String 型值，即：return类型必须和方法返回值类型相同；
4、由于方法执行后会返回一个结果，因此在调用带返回值方法时一般都会接收其返回值并进行处理。
import java.util.Arrays;
public class HelloWorld {
public static void main(String[] args) {
HelloWorld hello = new HelloWorld();
int ages = hello.getMaxAge();
System.out.println("最大年龄为：" + ages);
}
public int getMaxAge() {
int[]ages={18,23,21,19,25,29,17};
Arrays.sort(ages);
return ages[ages.length-1];
}
}

public class HelloWorld {

//完成 main 方法
public static void main(String[] args) {
// 创建对象，对象名为hello
HelloWorld hello = new HelloWorld();
// 调用方法并将返回值保存在变量中
int maxAge=hello.getMaxAge();
// 输出最大年龄
System.out.println("最大年龄为：" + maxAge);
}
/*
* 功能：输出学生年龄的最大值
* 定义一个无参的方法，返回值为年龄的最大值
* 参考步骤：
* 1、定义一个整形数组 ages ，保存学生年龄，数组元素依次为 18 ,23 ,21 ,19 ,25 ,29 ,17
* 2、定义一个整形变量 max ,保存学生最大年龄，初始时假定数组中的第一个元素为最大值
* 3、使用 for 循环遍历数组中的元素，并与假定的最大值比较，如果比假定的最大值要大，则替换当前的最大值
* 4、使用 return 返回最大值
*/
public int getMaxAge() {
int[] ages={18,23,21,19,25,29,17};
int max=ages[0];
for(int i=0;i<ages.length;i++){
if(max<ages[i]){
max=ages[i];
}
}
return max;
}
}
1.在方法中加入参数列表接收外部传入的数据信息.
2.我们把定义方法时的参数称为形参，目的是用来定义方法需要传入的参数的个数和类型；把调用方法时的参数称为实参，是传递给方法真正被处理的值。
3.调用带参方法时，必须保证实参的数量、类型、顺序与形参一一对应
4.调用方法时，实参不需要指定数据类型，
5. 方法的参数可以是基本数据类型，如 int、double 等，也可以是引用数据类型，如 String、数组等
6.当方法参数有多个时，多个参数间以逗号分隔
public class HelloWorld {
public static void main(String[] args) {

// 创建对象，对象名为hello
HelloWorld hello = new HelloWorld();

// 调用方法，传入两门课程的成绩
hello.calcAvg(94, 81);//调用的方法名和定义的方法的名称要一致
}

/*
* 功能：计算两门课程考试成绩的平均分并输出平均分
* 定义一个包含两个参数的方法，用来传入两门课程的成绩
*/
public void calcAvg(int score1,int score2){ //要明确方法的类型，
double avg=(score1+score2)/2.0;如果是void，则不要返回值，如果是其他的类型，需要有返回值
System.out.println("平均分："+avg);
}

import java.util.Arrays;

public class HelloWorld {
public static void main(String[] args) {
HelloWorld hello = new HelloWorld();
int[] scores={79,52,98,81};

//调用方法，传入成绩数组，并获取成绩的个数
int count=hello.sort(scores);

System.out.println("共有"+count+"个成绩信息！");
}

/*
* 功能：将考试成绩排序并输出，返回成绩的个数
* 定义一个包含整型数组参数的方法，传入成绩数组
* 使用Arrays类对成绩数组进行排序并输出
* 方法执行后返回数组中元素的个数
*/
public int sort(int[] scores){
Arrays.sort(scores);
System.out.println(Arrays.toString(scores));

//返回数组中元素的个数

return scores.length;
}
}

判断方法重载的依据：
1、必须是在同一个类中
2、方法名相同
3、方法参数的个数、顺序或类型不同
4、与方法的修饰符或返回值没有关系

//导入java.util.Arrays;
public class HelloWorld {
public static void main(String[] args) {

// 创建对象，对象名为hello
HelloWorld hello = new HelloWorld();

// 调用方法并将返回值保存在变量中
int[] nums = hello.getArray(8);

// 将数组转换为字符串并输出
System.out.println(Arrays.toString(nums));
}

/*
* 功能：创建指定长度的int型数组，并生成100以内随机数为数组中的每个元素赋值
* 定义一个带参带返回值的方法，通过参数传入数组的长度，返回赋值后的数组
*/
public int[] getArray(int length) {
// 定义指定长度的整型数组
int[] nums = new int[length];

// 循环遍历数组赋值
for ( int i=0;i<nums.length;i++) {

// 产生一个100以内的随机数，并赋值给数组的每个成员
nums[i]=(int)(Math.random()*100);

}
return nums; // 返回赋值后的数组
}
}

定义一个包含整型数组参数的方法，用来接收成绩数组，进行成绩排序并输出前三名
import java.util.Arrays;
public class HelloWorld {
public static void main(String[] args) {
int[] scores = {89, -23, 64, 91, 119, 52, 73};
HelloWorld hello = new HelloWorld();
int[] backScore = hello.getArays(scores);
for(int i=0;i<3;i++){
System.out.println("第"+(i+1)+"名的成绩是:"+backScore[i]);
}
}
public int[] getArays(int[] scores){
int count = 0;
int[] score = new int[3];
Arrays.sort(scores);
for(int i = scores.length-1; i>=0; i--){
if((scores[i]>100) && (scores[i]<0)){
continue;
}else{
score[count] = scores[i];
count++;
if(count == 3){
break;
}
}
}
return score;
}
}

java基础，

java基础，

相关文章

相关文章

用户点评