一、 初识Java
特性
- 简单性
- 面向对象
- 可移植性
- 高性能
- 分布式
- 动态性
- 多线程
- 安全性
- 健壮性
java三大版本
javaSE：标准版（桌面程序，控制台开发…）
javaME：嵌入式开发（手机，小家电…）
javaEE：企业级开发（web端，服务器开发…）
JDK、JRE、JVM
JDK：java开发者工具（包含JRE、JVM，面向开发者）
JRE：java运行时环境（包含JVM，面向使用者）
JVM：java虚拟机
java开发环境搭建
- JDK下载与安装
链接呈上：点击 - JDK目录介绍
bin目录 ：该目录里用于存放一些可执行文件 。例如:javac.exe(java编译器)，java.exe(java运行工具)，jar.exe(java打包工具)，Javadoc.exe(文档生成文件)等。
db目录：是一个小型的数据库。从jdk6.0开始有的，是一个纯java实现，开源的数据库管理系统，在学习jdbc的时候不需要额外地装一个数据库软件
include目录：由于JDK是通过c和c++实现的，所以这个目录中存储了一些在启动时需要引入的一些c语言的头文件。
jre目录 ：java程序的运行环境，该目录是java运行时环境的根目录，包含了java虚拟机，运行时的类包，java用启动器和一个bin目录，但是这个bin目录中存储的不包含开发环境中的开发工具。
lib目录 ：存储的是java 类库或库文件，是开发工具使用的归档包文件。
src.zip文件 ：存放的是JDK的核心类的源码。
- Hello World及简单的语法规则
1、在磁盘下新建一个文件夹，存放代码
2、新建一个后缀为java的文件，命名为Hello.java(注意文件类型，无后缀名需在 查看选项卡 中 勾选 文件扩展名 )
public class Hello{
public static void main(String[] args){
System.out.println("Hello World!!");
}
}
二、变量、数据类型和运算符
数据类型
1.基础数据类型
(1)整数型 byte(字节) short(短) int(整数) long(长)
(2)浮点型 float(单精度) double(双精度)
(3)字符型 char(字符)
(4)字符串型 String(字符串,string不是关键字)
(5)布尔型 boolean(布尔)
2.变量:随着程序运行可以它改变变量值
(1)声明变量的格式:
数据类型 变量名 = 变量的值
(2)各类型声明的示例:
int age = 18;
String name = “Dawn”
char sex = ‘男’
double mong = 9.3
boolean flag = true
3.变量名的命名规则
(1)变量名必须以字母, 下划线-- 或 $ 符号开头
(2)变量名可以包括数字,但不能以数字开头
(3)除 - $ 符号外,不能包括任何特殊符,包括空格 都不行
(4)不能使用Java的关键字, 如 int class new 等
4.各类型赋值需要注意的
(1)char类型赋值需要’’ 单引号引起
(2)String类型赋值需要"" 双引号引起
(3)boolean类型的值只可以是true false (利用于逻辑运算中的判断)
5.运算符
(1)赋值运算符
= 把右边的值赋给左边
(2)算数运算符
+ 加 - 减 * 乘 / 除 % 取余
(3)关系运算符
> 大于 < 小于 >= 大于等于 <=小于等于 == 等于 !=不等于
(4)逻辑运算符
&& 并且 || 或 ! 非
6.扫描仪
(1)使用步骤:
Scanner input = new Scanner(System.in);
(2)导包
import java.util.Scanner
(3)使用
int age = input.nextInt();
double money = input.nextDouble();
boolean fiag = input.nextBoolean();
String name = input.next()😕/获取空格前字符串
String name = input.nextLine();//获取字符串,包括空格
char sex = input.next().charAt(0);
注意:严格区分大小写
7.类型转换
(1)自动类型转换
类型互相兼容
当将一个数值范围小的类型赋给一个数值范围大的数值类型变量
Java在编译过程中将此数值类型进行自动提升
(2)强制类型转换
当将一个数值范围大的类型变量给一个数值范围小的数值类型变量 编译会报错
这时候要用到强制类型转换
示例:
double num1 = 9.99;
int num2 = (int)num1;
*强制类型转换会造成数据类型丢失,值点后的小数消失
(3)字符类型和数字类型累加的时候,字符类型会使用标准编码数字累加
三、选择结构
1.if选择结构
if选择结构是根据条件判断之后再做处理的一种语法结构
语法：
if(条件){
代码块 //条件成立之后要执行的代码，可以是一条语句，也可以是一组语句
}
if选择结构流程图
if后小括号里的条件是一个表达式，而且表达式的值必须为ture 或 false。
1.1使用基本的if选择结构
import java.util.Scanner;
public void GetPrize{
Scanner input = new Scanner(System.in);
System.out.print("请输入成绩");
int score = input.nextInt();
if(socre > 98){
System.out.println("考的不错，奖励");
}
}
运行结果：请输入成绩：100
考的不错，奖励
1.2使用复杂条件下的if选择结构
常用的逻辑运算符
程序：如果Java成绩大于98分，而音乐成绩大于80分，则奖励；如果Java成绩等于100分，音乐成绩大于70分，也奖励
1 public class GetPrize2(){
2 public static void main(String[] args){
3 int javaScore = 100;
4 int muicScore = 72;
5 if((javaScore > 98 && muicScore > 80) || (javaScore == 100 && muicScore > 70)){
6 System.out.println("考的不错，奖励");
7 }
8 }
}
运行结果：考的不错，奖励
1.3使用if-else选择结构
if(条件){
//代码块1
}else{
//代码块2
}
if-else结构流程图
流程图
程序：如果Java成绩大于98，奖励；否则继续编写代码
1 public class SimpieIf{
2 public static void main(String[] args){
3 int score = 91;
4 if(score > 91){
5 System.out.println("考的不错，奖励");
6 }else{
7 System.out.println("继续编写代码吧");
8 }
9 }
10 }
运行结果：继续编写代码吧。
1.4多重if选择结构
语法：
if(条件1){
//代码块1
}else if(条件2){
//代码块2
}else{
//代码块3
}
多重if选择结构流程图
流程图
1）else if 可以有多个或者没有，有几个else if块完全取决于需要
2）else 块最多有一个或没有，else块必须放在else if块之后
程序：对学生的成绩进行评测，成绩>=80为良好，成绩>=60为中等，成绩<60为差
1 public class ScoreAssess{
2 public static void main(String[] args){
3 int score = 70;
4 if(score >= 80){
5 System.out.println("良好");
6 }else if(score >= 60){
7 System.out.println("中等");
8 }else{
9 System.out.println("差");
10 }
11 }
12 }
程序运行结果：中等
1.5嵌套if选择结构
语法：
if(条件1){
if(条件2){
//代码块1
}else{
//代码块2
}
}else{
//代码块3
}
嵌套if结构流程图
流程图
程序：学校举行运动会，百米赛跑成绩在10s内的有资格进入决赛，根据性别分为男子组和女子组
import java.util.*;
public class Runing{
public static void main(String[] args){
Scanner input = new Scanner(System.in);
System.out.print("请输入比赛成绩（s）：");
double score = input.nextDouble();
System.out.print("请输入性别：");
String gender = input.next();
if(score < 10){
if(gender.equals("男")){
System.out.print("进入男子组决赛");
}else if(gender.equals("女")){
System.out.print("进入女子组决赛");
}
}else{
System.out.print("淘汰");
}
}
}
运行结果：请输入比赛成绩（s）：8
请输入性别： 男
进入男子组决赛
注意：1）只有当满足外层if选择结构的条件时，才会判断内层if的条件
2）else 总是与他前面最近的缺少 else 的那个 if 相配对
2.switch选择结构
语法：
switch(表达式){
case 常量1：
//代码块1;
break;
case 常量2:
//代码块2;
break;
... ...
default:
//代码块n;
break;
}
1)JDK 1.7后，switch 语句小括号里可以是 int、short、byte、char、枚举、String类型表达式
2）case 后必须是一个常量，数据类型与switch后表达式的值相同，通常是一个固定值，case块可以有多个，顺序可以改变，但每个case后的值必须各不相同
3）default:其他情况都不满足时执行default。default后要紧跟冒号，default跟case的顺序可以变动，但通常default块放在结尾，也可以省略。
程序：参加计算机编程大赛：
如果获得第一名，奖励参加下列营；
如果获得第二名，奖励惠普笔记本电脑一台；
如果获得第三名，奖励移动硬盘一个；
否则没有奖励。
1 public calss Compete{
2 public static void main(String[] args){
3 int rank = 1;
4 switch(rank){
5 case 1:
6 System.out.println("参加夏令营");
7 break;
8 case 2:
9 System.out.println("惠普笔记本");
10 break;
11 case 3:
12 System.out.println("移动硬盘");
13 break;
14 default:
15 System.out.println("没有奖励");
16 break;
17 }
18 }
19 }
运行结果：参加夏令营
3.选择结构总结
1）基本if选择结构：可以处理单一或组合条件的情况。
2）if-else选择结构：可以处理简单的条件分支情况。
3）多重if选择结构：可以处理复杂的条件分支情况。多重if选择结构在解决需要判断的条件是连续的区间时有很大的优势。
4）嵌套if选择结构：这种结构一般用于复杂的流程控制中。
5）switch选择结构：当需要多重分支，并且条件判断是等值判断的情况下，使用switch选择结构代替多重if选择结构会更简单，代码结构更清晰易读
四、循环结构
1.while循环结构
语法：
while(循环条件){
//循环操作
}
while循环结构流程图：
流程图
举例：
1 int i = 1;
2 while(i <= 100){
3 System.out.printlen("好好学习");
4 i ++;
5 }
注：关键字while后小括号中的内容是while循环条件。循环条件是一个表达式，它的值为布尔类型，即ture或false。{ }中的语句统称为循环操作，又称循环体。
while循环结构的结构的执行顺序一般如下、
1）声明并初始化循环变量
2）判断循环条件是否满足，如果满足，则执行循环操作，否则退出循环
3）执行完循环操作后，再次判断循环条件，决定继续执行循环或者退出循环
while循环的一个特点：先判断，再执行。
2. do-while循环
语法
do{
//循环操作
}while(循环条件);
do-while循环的流程图
流程图
举例：
1 int i = 1;
2 do{
3 System.out.println("好好学习");
4 i++;
5 }while(i <= 100);
注：do-while循环结构以分号结尾。
do-while循环的执行顺序一般如下：
1）声明并初始化循环变量
2）执行一遍循环操作
3）判断循环条件，如果循环满足条件，则循环继续执行，否则退出循环
do-while循环的特点：先执行，后判断。
3.for 循环
语法：
for(表达式1;表达式2;表达式3){
//循环体
}
表达式1：赋值语句
表达式2：条件语句
表达式3：赋值语句
五、数组
什么是数组？
数组是一组相同数据类型元素的集合。在Java中数组属于引用类型，即数组是一个对象。这里的数据类型不仅含八大基本数据类型，还包含引用数据类型，如数组里面可以存数组,数组里面可以存放字符串。
数组的作用？
在程序中常常需要使用数组，利用循环可以对数组中的数据进行批量操作，大大提高了效率，十分方便。
如何使用数组？
数组的声明方式：
1.数据类型 [] 数组名称 eg：int [] a;
2数据类型 数组名称 [] eg：int a [];
注：推荐使用第一种声明方式，因为可以方便看出变量a是一个整型数组类型。此时a并没有指向具体的一块堆内存，因此它的默认值为null.
数组的初始化:
1.动态初始化： 数据类型 [] 数组名称 = new 数据类型 [长度]；
eg： int [] arr = new int [10];然后通过下标索引为每个元素赋值。
public class Test
{
public static void main(String[] args)
{
// 动态初始化
int[] arr = new int [5];
arr[0] = 0;
arr[1] = 1;
arr[2] = 3;
arr[3] = 4;
arr[4] = 5;
// 利用循环实处每一个元素的值
for(int i = 0;i < arr.length;i++)//数组名.length就是数组长度
{
System.out.print(arr[i]+" ");
}
}
}
注：new关键字的含义是在堆上开辟一块新的空间。只要有new关键字的出现，就意味着有新空间的开辟。
因此
2.静态初始化：在定义数组的同时设置元素的值。
简化格式：
数据类型 [] 数组名称 = {值1，值2，…};
完整格式：
数据类型 [] 数组名称 = new 数据类型 [] {值1，值2，…};
public class Test
{
public static void main(String[] args)
{
int[] arr1={1,2,3,4,5};//简化格式
int[] arr2 = new int []{1,2,3,4,5};//完整格式
}
}
匿名数组
利用完整格式，可以方便使用匿名数组。
匿名数组就是没有名称的数组，本质是一块没有栈内存指向的堆内存。只能使用一次，用完就被回收了。
public class Test
{
public static void main(String[] args)
{
int[] arr = init();
for(int i=0; i < arr.length;i++)
{
System.out.print(arr[i]+" ");
}
System.out.println();
}
public static int[] init()
{
return new int[]{1,2,3,4,5};//方法返回一个匿名数组
}
}
二维数组
概念：数组里的每一个元素都是是一个一维数组的数组被称为二维数组。
定义： 静态初始化：
int[][] arr1 = {{1,2,3},{1,2}};//简化格式
int[][] arr2 = new int[][] {{1,2,3},{4,5}};//完整格式
动态初始化：
int arr[][] = new int[2][3];//2 行个数，3，列个数
注：其中列个数可以省略不写，因为Java中的二维数组存在不规则矩阵这样的数组，因此写了也没有多大意义。
eg：不规则二维数组的使用：
public class Test
{
public static void main(String[] args)
{
int[][] arr=new int[3][]
{
{1,2,3,4},
{1,2},
{3,4}
};
for(int i=0;i<arr.length;i++) //利用两重for循环打印输出二维数组的元素。
{
for(int j=0;j<arr[i].length;j++)
{
System.out.print(arr[i][j]+" ");
}
System.out.println();
}
}
}
输出结果：
在C语言中二维数组每一行的个数都是相同的。
利用增强型for循环（foreach循环）打印多维数组
格式：for（part1：part2）{part3}
part2 是一个数组对象
part1：定义一个变量，变量的类型是数组中元素的类型。
part3：循环体
原理：将part2 数组中的元素值拷贝一份逐一赋给part1，然后利用part3循环体将值打印出来。因此该循环只能作为输出不能修改数组中元素的值。因为它仅是一份值得拷贝。
public class Foreach
{
public static void main(String[] args)
{
int[] arr1=new int[]{1,2,3,4,5};
int[][] arr2=new int[][]{{1,2,3},{4,5}};
int[][][] arr3=new int[][][]{{{1,2,3},{4,5}}};
//方法重载，方法的新参类型不同。
printArr(arr1);
printArr(arr2);
printArr(arr3);
}
// 利用增强型for循环打印一维数组
public static void printArr(int[] arr)
{
for(int i: arr)
{
System.out.print(i+" ");
}
System.out.println();
}
// 利用增强型for循环打印二维数组
public static void printArr(int[][] arr)
{
for(int[] data:arr)
{
for(int i: data)
{
System.out.print(i+" ");
}
}
System.out.println();
}
// 利用增强型for循环打印三维数组
public static void printArr(int[][][] arr)
{
for(int[][]data:arr)
{
for(int[]daat:data)
{
for(int i:daat)
{
System.out.print(i+" ");
}
}
}
System.out.println();
}
}
出结果：
利用增强型for循环输出多维数组和一维数组的本质思想是一样的。
以二维数组为例：
首先二维数组的每一个元素类型都是一维数组，因此第一个增强型for循环的第一个局部变量为一维数组类型，第二部分是二维数组名。但不能利用循环体直接将一维数组整体输出。因此需要再嵌套一个增强型for循环，此时的for循环里的局部变量类型为外部增强型for循环里面的一维数组元素的类型，第二部分是第一层增强型for循环里的一维数组本身。然后循环体中依次输出这个局部变量即OK了！
引用传递
概念：多个栈空间同时指向同一块堆内存
赋值语句从右向左执行，因此首先执行new int[] {1,2,3}，则在堆上开辟12个字节的空间，每四个分别用来存放arr[0],arr[1],arr[2],并对它们进行初始化。然后在栈上为局部变量arr分配空间，并将堆空间的地址（首地址）存到栈空间的arr里面，此时栈上的arr的值就是堆上的数组空间的地址，因此二者建立了一定联系，这里用指向来表示。
再接着在栈上定义了一个局部变量x，并把arr的值赋给x，因此x里面也存的是堆空间的首地址，此时x也指向那块堆空间，利用x也可对堆空间的值进行操作，这便称为引用传递。本质：多个栈空间同时指向同一块堆内存。没有栈内存指向的堆内存也被称为垃圾空间。
注：在C语言里面曾经学过，在函数内部修改其它函数局部变量的值可以通过该变量的地址或者返回值的方式。因此我们可以利用引用传递来修改堆空间的值。
数组常用操作
Java中提供了很多对数组操作的方法可以方便得实现对数组的各种操作。
1.数组长度： 数组名.length
2.数组排序： java.util.Arrays.sort(数组名) 升序
3.数组扩容：java.util.Arrays.(数组名称，新数组长度）
（这个很像C语言中的realloc函数）。
4.在数组中查找指定元素：Arrays.binarySearch(数组，指定元素)。
（看名字像是二分查找实现的）。
5.数组拷贝：System.arraycopy(源数组名称，源数组开始点，目标数组 名称，目标数组开始点，拷贝长度)。
六、循环结构进阶
1.什么是二重循环：
一个循环体内又包含另一个完整的循环结构
语法：
while(循环条件1) {
//循环操作1
while(循环条件2) {
//循环操作2
}
}
do {
//循环操作1
do {
//循环操作2
}while(循环条件1);
}while(循环条件2);
for(循环条件1) {
//循环操作1
for(循环条件2) {
//循环操作2
}
}
while(循环条件1) {
//循环操作1
for(循环条件2) {
//循环操作2
}
}
※各种循环可以相互嵌套
2.二重循环执行顺序：
外层循环执行1次内层循环执行1周
案例：
若有3个班级各4名学员参赛，如何计算每个班级参赛学员的平均分？
public class Demo02 {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
//二重循环
/**
*
* 外层循环执行一次，内层循环执行1周
*
*/
for (int i = 1; i <=3; i++) {
System.out.println("*************************************");
System.out.println("请输入第"+i+"个班级4位学员的成绩：");
int [] scores=new int[4]; //学员成绩数组
double sum=0.0; //计算总和
for (int j = 0; j <scores.length; j++) {
System.out.println("请输入第"+(j+1)+"位学员的成绩：");
scores[j]=input.nextInt();
sum=sum+scores[j];
}
System.out.println("第"+i+"个班级的平均分为："+sum/scores.length);
}
}
}
案例：打印矩形
public class Demo03 {
public static void main(String[] args) {
//外层循环控制行数
for (int i = 1; i <=5; i++) {
//内层循环控制个数
for (int j = 1; j <=5; j++) {
System.out.print("*");
}
System.out.println();
}
}
}
3.在二重循环中使用 continue：使用continue代表结束当前循环，继续下一次循环
案例：若有3个班级各4名学员参赛，计算每个班级参赛学员平均分，统计成绩大于85分学员数
public class Demo04 {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
//二重循环
/**
*
* 外层循环执行一次，内层循环执行1周
*
*/
int count=0; //存储大于85分的人数
for (int i = 1; i <=3; i++) {
System.out.println("*************************************");
System.out.println("请输入第"+i+"个班级4位学员的成绩：");
int [] scores=new int[4]; //学员成绩数组
double sum=0.0; //计算总和
for (int j = 0; j <scores.length; j++) {
System.out.println("请输入第"+(j+1)+"位学员的成绩：");
scores[j]=input.nextInt();
sum=sum+scores[j];
if(scores[j]<85){
//结束本次循环，进入下一次循环
continue;
}
count++;
}
System.out.println("第"+i+"个班级的平均分为："+sum/scores.length);
}
System.out.println("分数大于85的人数："+count);
}
}
4.在二重循环中使用 break：使用break代表结束（跳出）当前循环
案例：有5家衣服专卖店，每家最多购买3件。用户可以选择离开，可以买衣服 最后打印总共买了几件衣服
public class Demo05 {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
int count=0;
//外层循环控制5家店
for (int i = 1; i <=5; i++) {
System.out.println("欢迎光临第"+i+"家店");
//内层循环控制最多买3件衣服
for (int j = 1; j <=3; j++) {
System.out.println("是否离开（y/n）");
char chois=input.next().charAt(0);
if(chois=='y'){
//如果输入Y代表离开
break;
}
System.out.println("买了一件衣服");
count++;
}
}
System.out.println("共买了"+count+"件衣服");
}
}
七、类和对象
一.※ 万物皆对象
二.对象的两个特征：
属性：对象具有的各种特征
方法：对象执行的操作
对象：用来描述客观事物的一个实体，由一组属性和方法构成
三.封装：
对象同时具有属性和方法两项特性
对象的属性和方法通常被封装在一起，共同体现事物的特性， 二者相辅相承，不能分割
四.类
类是对象的类型
五.类和对象的关系
类是抽象的概念，仅仅是模板
比如说：“人”
对象是一个你能够看得到、摸得着的具体实体
※ 类是对象的类型，对象时类的实例
八、类的无参方法
Java注释：
//:单行注释
/**/：多行注释
/** */：JavaDoc注释
方法：
语法：
访问修饰符 返回值类型 方法名(){
方法体
}
举例：
public void run(){
System.out.println("");
}
public String robball(){
String ball="球";
return ball;
}
方法的返回值：
1.如果方法具有返回值，方法中必须使用关键字return返回该值，返回值类型为该返回值的类型
return 表达式； 作用： 跳出方法、返回结果
2.如果方法没有返回值，返回值类型为void
案例：
public class Lion {
//颜色属性
String color;
int age;
public void run(){
System.out.println("狮子正在跑");
}
public void say(){
System.out.println("狮子饿了，叫着要吃饭");
}
public String robBall(){
System.out.println("呵呵");
String ball="排球";
return ball;
}
//获取狮子的年龄
public int getAge(){
int age=18;
return age;
}
}
public class Test {
public static void main(String[] args) {
Lion lion = new Lion();
/*lion.run();
String ball = lion.robBall();
System.out.println("狮子正在玩：" + ball);
System.out.println("方法执行完毕之后回来！");
*/
System.out.println(lion.getAge());
}
}
局部变量和成员变量：
作用域不同
局部变量的作用域仅限于定义它的方法
成员变量的作用域在整个类内部都是可见的
初始值不同
Java会给成员变量一个初始值
Java不会给局部变量赋予初始值
注意：
在同一个方法中，不允许有同名局部变量
在不同的方法中，可以有同名局部变量
在同一个类中，成员变量和局部变量同名时，局部变量具有更高的优先级
九、带参数的方法
1.定义带参数的方法
①带参数：方法中某种功能的实现依赖于我们给它的初始信息，这时候在定义方法时需要在括号中加入参数列表
②语法：
访问修饰符 返回值类型 方法名(参数列表){
//方法的主体
}
2.调用带参的方法
①语法：
对象名.方法名(参数1,参数2,...)
②注意：
(1)先实例化对象，在调用方法
(2)实参的类型、数量、顺序要与形参的一一对应
3.带多个参数的方法
带参方法的参数个数无论多少，在使用时只要注意实参和形参一一对应：传递实参值与形参的数据类型相同、个数相同、顺序一致
4.常见错误
①代码中，调用方法时，在传递的实参前不添加数据类型
正确格式：对象名.方法名（<要赋予的内容>）
②代码中，形参和实参的数据类型要一致、数量要一致、数序要一致
③方法定义有返回值，但是调用该方法后没有对返回值进行任何处理（语法结构上不错，但程序设计上算程序设计错误的一种）
5.换行、空格
\n\t\r
6.数组作为参数的方法
//求五位同学的成绩的平均分及最高分
public class StudentsBiz1 {
/**
* 求平均分
*/
public double calAvg(int[] scores){
int sum=0;//总成绩
double avg=0.0;//平均分
for(int i=0;i<scores.length;i++){//遍历数组，累计总成绩
sum+=scores[i];
}
avg=(double)sum/scores.length;//平均成绩=总成绩/数组长度
return avg;
}
/**
* 求最高分
*/
public int calMax(int[] scores){
int max=scores[0];//当前最高分
for(int i=1;i<scores.length;i++){//遍历数组，找最大值
if(max<scores[i]){//如果当前最大值<当前数，则赋值给最大值
max=scores[i];
}
}
return max;
}
}
//测试类
import java.util.Scanner;
public class TestCal {
public static void main(String[] args) {
StudentsBiz1 st=new StudentsBiz1();
int[] scores=new int[5];//保存比赛成绩
Scanner input=new Scanner(System.in);
System.out.println("请输入五名参赛者的成绩：");
for(int i=0;i<5;i++){
scores[i]=input.nextInt();
}
//输出平均成绩
double avgScore=st.calAvg(scores);
System.out.println("平均成绩："+avgScore);
//输出最高成绩
int maxScore=st.calMax(scores);
System.out.println("最高成绩："+maxScore);
}
}
7.对象作为参数的方法
//添加学生信息
/**
* 学生类
*/
class Student{
public int id;//序号
public String name;//姓名
public int age;//年龄
public int score;//得分
public void showInfo(){
System.out.println("序号\t姓名\t年龄\t得分");
System.out.println(id+"\t"+name+"\t"+age+"\t"+score);
}
}
/**
*学生管理类
*/
public class StudentsBiz2 {
Student[] students=new Student[30];//学生数组
/**
* 增加学生
*/
public void addStudent(Student stu){//传参stu
for(int i=0;i<students.length;i++){//遍历数组，录入stu的信息
if(students[i]==null){//当前数组为空时将信息传入
students[i]=stu;
break;
}
}
}
/**
* 显示本班学生信息
*/
public void showStudents(){
System.out.println("本班学生列表：");
for(int i=0;i<students.length;i++){//遍历数组输出信息
if(students[i]!=null){//当前数组中不为空则调用输出
students[i].showInfo();
//break;//加break则执行一次结束
}
}
System.out.println();
}
}
//测试类
import java.util.Scanner;
public class TsetAdd2 {
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
//实例化学生对象并初始化
Student student1=new Student();//创建对象1
//给对象1赋值
student1.id=10;
student1.name="王紫";
student1.age=18;
student1.score=99;
Student student2=new Student();//创建对象2
//给对象2赋值
student2.id=11;
student2.name="郝湉";
student2.age=19;
student2.score=60;
//新增学生对象
StudentsBiz2 studentsBiz=new StudentsBiz2();//创建StudentsBiz2对象
studentsBiz.addStudent(student1);//调用
studentsBiz.addStudent(student2);
studentsBiz.showStudents();//显示学生信息
}
//对象作为参数
//用类名声明的数组称之为对象数组 存储的元素都是该类的对象
/*TsetAdd2 arr[]=new TsetAdd2[5];
* arr[0]=student1;//类类型
* arr[1]=student2;
*/
}
8.为什么需要包
①包允许将类组合成较小的单元（类似文件夹），易于找到和使用相应的类文件。
②防止命名冲突。
③包允许在更广的范围内保护类、数据和方法，可以在包内定义类。
9.如何声明包
①要声明一个包（package），只要包含一个package命令作为一个Java源文件的第一条语句就可以。
②语法
package 包名;
package是关键字，包的声明必须是Java源文件中的第一条非注释性的语句，而且一个源文件只能有一个声明包的语句。
③包名规范
（1）Java包的名字通常由小写字母组成，不能以圆点开头或结尾
（2）一个唯一包名的前缀通常是全部的小写的ASCLL字母，并且是一个顶级域名com、edu、gov、net或org，通常使用组织的网络域名的逆序。
（3）包名的后续部分依不同机构各自内部的规范不同而不同。 这类命名规范可能以特定目录名的组成来区分部门、项目、机器或注册名。
10.使用MyEclipse创建包
方法一：分别创建包和类
方法二：在创建类的过程中创建类所属的包
11.如何导入包
①语法：
import 包名.类名;
②如果要使用包下的某些类（多于一个）在使用import导入时，可以使用“包名.*”
语法：
import包名.*;
③注意：包的声明位于源文件的第一条语句，import语句要写在类定义之前
④小结：
(1)声明包的含义：生命在当前类所处的位置
(2)导入包的含义：声明在当前类中要使用到的其他类所处的位置
十、字符串
Java字符串String类操作方法详细整理
关于String类的基本操作，可分为以下几类：
1、基本操作方法
2、字符串比较
3、字符串与其他数据类型之间的转换
4、字符与字符串的查找
5、字符串的截取与拆分
6、字符串的替换与修改
我觉得在整理到下面的内容之前需要给自己提的醒是关于字符串的操作方法我们是不需要像其他操作一样手动导包的，其String和StringBuffer等类封装在java.lang包中，我们直接调用字符串方法即可！
一、String基本操作方法
首先说一下基本操作方法，字符串的基本操作方法中包含以下几种：
(1)获取字符串长度length()
(2)获取字符串中的第i个字符charAt(i)
(3)获取指定位置的字符方法getChars(4个参数)
1、 获取字符串长度方法length()
格式：int length = str.length();
2、获取字符串中的第i个字符方法charAt(i)
格式：char ch = str.charAt(i); //i为字符串的索引号，可得到字符串任意位置处的字符，保存到字符变量中
3、获取指定位置的字符方法getChars(4个参数)
格式：char array[] = new char[80]; //先要创建以一个容量足够大的char型数组，数组名为array
str.getChars(indexBegin,indexEnd,array,arrayBegin);
解释一下括号中四个参数的指向意义：
1、indexBegin：需要复制的字符串的开始索引
2、 indexEnd: 需要复制的字符串的结束索引，indexEnd-1
3、array: 前面定义的char型数组的数组名
4、arrayBegin:数组array开始存储的位置索引号
这样我们就可以将字符串中想要的范围内的字符都复制到字符数组中，将字符数组打印输出即可。
与getChars()类似的方法有一个getBytes(),两者使用上基本相同，只是getBytes()方法创建的是byte类型的数组，而byte编码是默认字符集编码，它是用编码表示的字符。
下面就上代码简单演示一下三种方法的用法：
1 //String类基本操作方法
2 public class StringBasicOpeMethod {
3 public static void main(String args[]){
4 String str = "如何才能变得像棋哥一样优秀？算了吧，憋吹牛逼！"; //定义一个字符串
5 System.out.println(str); //输出字符串
6 /***1、length()方法***/
7 int length = str.length();//得到字符串长度
8 System.out.println("字符串的长度为："+length);
9 /***2、charAt()方法***/
10 char ch = str.charAt(7); //得到索引为7的字符
11 System.out.println("字符串中的第8个字符为："+ch);
12 /***3、getChars()方法***/
13 char chardst[] = new char[80]; //定义容量为80的字符数组，用于存储从字符串中提取出的一串字符
14 str.getChars(0,14,chardst,0);
15 //System.out.println("字符数组中存放的内容为："+chardst);//错误，输出的是编码
16 System.out.println(chardst); //**括号中不可带其他字符串
17 }
18 }
运行结果如下：
二、字符串比较
我们知道，明确的数值之间可以很方便地进行比较，那么字符串该如何进行比较呢？字符串的比较是将两个字符串从左到右逐个字符逐个字符进行比较，比较的依据是当前字符的Uncode编码值，直到比较出两个不同字符的大小。
字符串比较也分为两大类：一类是字符串大小的比较，这样的比较有三种结果，大于、等于以及小于；还有一类比较方法就是比较两个字符串是否相等，这样产生的比较结果无非就两种，ture和false。
1、首先看一下第一种比较大小这类需求中的方法：
(1)不忽略字符串大小写情况下字符串的大小比较方法compareTo(another str)
格式：int result = str1.compareTo(str2);
输出三种比较结果：若该字符串的Unicode值<参数字符串的Unicode值，结果返回一负整数；若若该字符串的Unicode值=参数字符串的Unicode值，结果返回0；若该字符串的Unicode值>参数字符串的Unicode值，结果返回一正整数。
(2) 忽略字符串大小写情况下字符串的大小比较方法compareTOIgnoreCase(another str)
格式：int result = str1.compareToIgnoreCase(str2);
在忽略字符串大小写情况下，返回三种比较结果：输出三种比较结果：若该字符串的Unicode值<参数字符串的Unicode值，结果返回一负整数；若若该字符串的Unicode值=参数字符串的Unicode值，结果返回0；若该字符串的Unicode值>参数字符串的Unicode值，结果返回一正整数。
2、然后看一下第二种判别两种字符串是否相等(相等情况下必须保证二者长度相等)需求中的方法：
(1)不忽略字符串大小写情况下判别字符串相等的方法eaquals(another str)
格式：boolean result = str1.equals(str2);
当且仅当str1和str2的长度相等，且对应位置字符的Unicode编码完全相等，返回true,否则返回false
(2) 忽略字符串大小写情况下判别字符串相等的方法equalsIgnoreCase(another str)
格式：boolean result = str1.equals(str2);
demo如下：
1 public class StringCompareMethod {
2 public static void main(String args[]){
3 String str1 = "elapant";
4 String str2 = "ELEPANT"; //定义两个字符串
5 String str3 = "Apple";
6 String str4 = "apple";
7 /***1、compareTo方法***/
8 //不忽略字符串字符大小写
9 if(str1.compareTo(str2)>0){
10 System.out.println(str1+">"+str2);
11 }else if(str1.compareTo(str2) == 0){
12 System.out.println(str1+"="+str2);
13 }else{
14 System.out.println(str1+"="+str2);
15 }
16 /***2、compareToIgnoreCase()方法***/
17 //忽略字符串字符大小写
18 if(str1.compareToIgnoreCase(str2)>0){
19 System.out.println(str1+">"+str2);
20 }else if(str1.compareToIgnoreCase(str2) == 0){
21 System.out.println(str1+"="+str2);
22 }else{
23 System.out.println(str1+"<"+str2);
24 }
25 /***3、equals()方法***/
26 //不忽略字符串字符大小写
27 if(str3.equals(str4)){
28 System.out.println(str3+"="+str4);
29 }else{
30 System.out.println(str3+"!="+str4);
31 }
32 /***4、equalsIgnoreCase()方法***/
33 //忽略字符串字符大小写
34 if(str3.equalsIgnoreCase(str4)){
35 System.out.println(str3+"="+str4);
36 }else{
37 System.out.println(str3+"!="+str4);
38 }
39 }
40 }
运行结果如下：
三、字符串与其他数据类型的转换
有时候我们需要在字符串与其他数据类型之间做一个转换，例如将字符串数据变为整形数据，或者反过来将整形数据变为字符串类型数据，"20"是字符串，20就是整形数。我们都知道整形和浮点型之间可以利用强制类型转换和自动类型转换两种机制实现两者之间的转换，那么"20"和20这两种属于不同类型的数据就需要用到String类提供的数据类型转换方法了。
由于数据类型较多，因而转换使用的方法也比较多，在此我就用一个表格罗列一下：
简单测试的小demo如下：
public class StringConvert {
public static void main(String args[]){
/***将字符串类型转换为其他数据类型***/
boolean bool = Boolean.getBoolean("false"); //字符串类型转换为布尔类型
int integer = Integer.parseInt("20"); //字符串类型转换为整形
long LongInt = Long.parseLong("1024"); //字符串类型转换为长整形
float f = Float.parseFloat("1.521"); //字符串类型转换为单精度浮点型
double d = Double.parseDouble("1.52123");//字符串类型转换为双精度浮点型
byte bt = Byte.parseByte("200"); //字符串类型转换为byte型
char ch = "棋哥".charAt(0);
/***将其他数据类型转换为字符串类型方法1***/
String strb1 = String.valueOf(bool); //将布尔类型转换为字符串类型
String stri1 = String.valueOf(integer); //将整形转换为字符串类型
String strl1 = String.valueOf(LongInt); //将长整型转换为字符串类型
String strf1 = String.valueOf(f); //将单精度浮点型转换为字符串类型
String strd1 = String.valueOf(d); //将double类型转换为字符串类型
String strbt1 = String.valueOf(bt); //将byte转换为字符串类型
String strch1 = String.valueOf(ch); //将字符型转换为字符串类型
}
}
四、字符串查找
我们有时候需要在一段很长的字符串中查找我们需要的其中一部分字符串或者某个字符，String类恰恰提供了相应的查找方法，这些方法返回的都是目标查找对象在字符串中的索引值，所以都是整形值。具体分类情况如下：
字符串查找无非分为两类：查找字符串和查找单个字符，而查找又可分为查找对象在字符串中第一次出现的位置和最后一次出现的位置，再扩展一步，我们可以缩小查找范围，在指定范围之内查找其第一次或最后一次出现的位置。
（1）查找字符出现的位置
1、indexOf()方法
格式：1、str.indexOf(ch);
2、str.indexOf(ch,fromIndex); //包含fromIndex位置
格式1返回指定字符在字符串中第一次出现位置的索引
格式2返回指定索引位置之后第一次出现该字符的索引号
2、lastIndexOf()方法
格式：1、str.lastIndexOf(ch);
2、str.lastIndexOf(ch,fromIndex);
格式1返回指定字符在字符串中最后一次出现位置的索引
格式2返回指定索引位置之前最后一次出现该字符的索引号
(2) 查找字符串出现的位置
1、indexOf()方法
格式：1、str.indexOf(str);
2、str.indexOf(str,fromIndex);
格式1返回指定子字符串在字符串中第一次出现位置的索引
格式2返回指定索引位置之前第一次出现该子字符串的索引号
2、lastIndexOf()方法
格式：1、str.lastIndexOf(str);
2、str.lastIndexOf(str,fromIndex);
格式1返回指定子字符串在字符串中最后一次出现位置的索引
格式2返回指定索引位置之前最后一次出现该子字符串的索引号
看代码：
//字符与字符串查找
public class StringSearchChar {
public static void main(String args[]){
String str = "How qi bocome handsome like qi ge"; //定义一个长字符串
System.out.println("该字符串为："+str);
/***1、indexOf()方法查找字符首个出现位置格式1,2***/
int index1 = str.indexOf(" "); //找到第一个空格所在的索引
int index2 = str.indexOf(" ",4); //找到索引4以后的第一个空格所在索引
System.out.println("第一个空格所在索引为："+index1);
System.out.println("索引4以后的第一个空格所在索引为："+index2);
System.out.println("*****************");
/***2、lastIndexOf()方法查找字符最后出现位置格式1,2***/
int index3 = str.lastIndexOf(" "); //找到最后一个空格所在的索引
int index4 = str.lastIndexOf(" ",10);//找到索引10以后的第一个空格所在索引
System.out.println("最后一个空格所在索引为："+index3);
System.out.println("索引10以前最后一个空格所在索引为："+index4);
System.out.println("*****************");
/***3、indexOf()方法查找子字符串第一次出现位置格式1,2***/
int index5 = str.indexOf("qi"); //找到"qi"子字符串第一次出现位置的索引
int index6 = str.indexOf("qi",5);//找到索引5以后子字符串"qi"第一个出现位置所在索引
System.out.println("子字符串qi第一次出现位置的索引号为："+index5);
System.out.println("索引5以后子字符串qi第一次出现位置的索引号为："+index6);
System.out.println("*****************");
/***4、lastIndexOf()方法查找子字符串最后一次出现位置格式1,2***/
int index7 = str.lastIndexOf("qi");
int index8 = str.lastIndexOf("qi",5);
System.out.println("子字符串qi最后一次出现位置的索引号为："+index7);
System.out.println("索引号5以后子字符串qi最后一次出现位置的索引号为："+index8);
}
}
结果截图如下：
五、截取与拆分
这类方法是截取出一个长字符串中的一个子字符串或将字符串按照正则表达式的要求全部拆分保存到一个字符串数组中。具体方法如下所示：
(1) 截取方法
1、substring()方法
格式1：String result = str.substring(index)；
格式2：String result = str.substring(beginIndex,EndIndex)；//实际索引号[beginIndex,EndIndex-1]
结果：截取出范围内的字符串
（2）拆分方法
1、split()方法
格式1 ：String strArray[] = str.split(正则表达式);// 拆分的结果保存到字符串数组中
格式2：String strArray[] = str.split(正则表达式，limit);
代码示例如下：
//字符串截取与拆分
public class StringCutAndSplit {
public static void main(String args[]){
String str = "How to cut and split strings"; //定义字符串
System.out.println("字符串为："+str);
int length = str.length(); //获取字符串长度，保存到变量中
System.out.println("字符串长度为："+length);
/***1、substring()方法截取出第一个单词和最后一个单词***/
//首先配合indexOf()和lastIndexOf()方法找到第一个单词和最后一个单词前后空格的索引号
//第一个单词的左范围索引为0，最后一个单词的右范围索引为length-1
int firstIndex = str.indexOf(' '); //找到第一个空格所在位置
int lastIndex = str.lastIndexOf(' '); //找到最后一个空格所在位置
System.out.println("第一个空格的索引号为："+firstIndex);
System.out.println("最后一个空格的索引号为："+lastIndex);
//利用substring()方法根据第一个和最后一个单词的索引范围截取出第一个和最后一个单词
String firstWord = str.substring(0,firstIndex); //截取出第一个单词
String lastWord = str.substring(lastIndex+1,length);//截取出最后一个单词
System.out.println("第一个单词为："+firstWord);
System.out.println("最后一个单词为："+lastWord);
/***1、split()方法拆分出所有单词***/
String stringArray[] = str.split(" "); //根据空格要求拆分出所有单词保存到字符串数组中
System.out.println("拆分之后的各个词汇为："); //输出提示信息
for(int i = 0;i<stringArray.length;i++){
System.out.print(stringArray[i]+"\t");
}
}
}
代码执行结果如下：
六、替换或修改
终于到最后一类方法了，开心！！有时候我们需要对原字符串中的某些子字符串进行替换或修改，此时也需要String类提供的一些简单快捷好用的方法啦
（1）concat()方法：合并字符串
格式：String result = str1.concat(str2); //将str1和str2合并
(2) toLowerCase()方法：将字符全部转化为小写
格式: String result = str.toLowerCase();
(3) toUpperCase()方法： 将字符全部转化为大写
格式：String result = str.toUpperCase();
(4)replaceAll()、replaceFirst()方法：需要匹配正则表达式
代码如下：
//字符串替换与修改
public class StringFindandReplace {
public static void main(String args[]){
String str1 = "vbasic";
String str2 = "Vbasic";
System.out.println("str1 = "+str1);
System.out.println("str2 = "+str2);
/***1、concat()方法将两字符串合并***/
String str3 = str1.concat(str2);
System.out.println("str1和str2合并后的字符串为："+str3);
/***2、toLowerCase()方法将str1字符全部转换为小写***/
String str4 = str1.toLowerCase();
System.out.println("str1的字符全部转换为小写："+str4);
/***3、toUpperCase()方法将str2字符全部转换为大写***/
String str5 = str2.toUpperCase();
System.out.println("str2的字符全部转换为大写："+str5);
/***4、实现字符串的替换，原字符串内容不变***/
String str6 = str1.replaceFirst("(?i)VBASIC","C++");
String str7 = str2.replaceFirst("(?-i)VBASIC","C++");
System.out.println("替换后的str1："+str6);
System.out.println("替换后的str2:"+str7);
}
}
代码运行结果截图：
十一、吃货联盟
没
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
