java第一阶段
(初) 编写和运行Java程序的步骤
- 编写源代码,保存到源代码文件中,例如 HelloWorld.java
- 编译源代码,例如javac HelloWorld.java
- 执行字节码,例如java HelloWorld
案例1.1 HelloWorld
public class chushi {
public static void main(String[] args) {
System.out.println("HellowWorld!");
}
}
运行结果
HellowWorld!
1.源文件与class文件
在Java中源文件的名称必须是文件中主类的名称,扩展名必须为.java。源文件中可以包含多个类,但是最多只能有一个类使用public修饰,使用public修饰的类就是主类。在Java中,源文件还被作为编译单元,即一个源文件就是一个编译单元。
编译器会为源代码中的每个类生成一个.class文件,.class文件的名称是类的名称,扩展名为.class。
2.main()方法
方法名:只能是main,不能是Main等形式。
修饰符:public static void 三个缺一不可,多一个不行
示例
public static void main(String[] args) {
}
参数:
1、参数类型为字符串数组
2、参数名称只要符合Java中标识符命名要求即可
3、参数声明的两种方式:String[] args, 或 String args[]
(一)注释
注释的三种形式:单行注释、多行注释、文档注释
文档注释(documentation comment)以 “/*” 开始,以 “/” 结束。使用文档注释可以将关于程序的信息嵌入到程序自身中。
javadoc命令可以文档注释中的内容提取出来,将其放入到一个HTML文件中。文档注释方便了程序的文档化。
示例
//这是单行注释
/*
这是多行注释
*/
/**
* 这是文档注释
*/
1.分隔符、代码块
每行功能代码以;作为结束符号
空格没有实际意义,可以利用空格无意义,将代码合理缩进,易读
{}包含的代码称之为代码块, 例如类if(){}、方法{}、类{}等等
2.标识符
概念:Java中类、方法和变量的名称,称之为标识符。
2.1 标识符的语法要求
(1)以字母、数字、_或$组成
(2)不能以数字开头
(3)不能使用java的关键字和保留字
注意:
- 标识符的长度没有限制
- Java是大小写敏感的,所有标识符区分大小写
2.2标识符的命名规范(驼峰)
Java中的标识符通常是由多个英文单词构造,每个单词除了首字母外其他字母小写。
大驼峰
第一个单词的首字母大写。以大写字母开头,用于类名、接口名
class Accoun {…} //类名
class HelloWorld{…} //类名
interface AccountBase {…} //接口名
小驼峰
第一个单词的首字母是小写,其他单词的首字母大写。以小写字母或单词开头,用于变量名、方法名
String studentName; //变量名
String getStudentName() {…} //方法名
常量命令规范
常量是使用final修饰的存储单元。(最终的)
全部为大写字母表示
final public int DAYS_WEEK = 7;
final public double PI = 3.1415926;
标识符案例
演示标识符的要求、规范、常量的定义
abc a+b my_city $money class _78
myName _come my&bb 3name public
name#1 age- name3 class5 _$ $a
(二)Java的关键字
1.Java中的全部关键字
目前定义了50个关键字
abstract | continue | new | for | switch |
assert | default | package | goto | synchronized |
boolean | do | private | if | this |
break | double | protected | implements | throw |
byte | else | public | import | throws |
case | enum | return | instanceof | transient |
catch | extends | short | int | try |
char | final | static | interface | void |
class | finally | strictfp | long | volatile |
const | float | super | native | while |
Java保留了const和goto关键字,但是没有使用。Java还保留了下面这些关键字:true、false和null。这些关键字是Java定义的数值。
( 三)基本数据类型
1.数据类型的分类
基本数据类型:数值型,字符型,布尔型。
1.1数值型
数值类型细分可分为两大类,整数类型,浮点数类型。
1.11整数类型
- byte类型,即1个字节,取值范围从-128到127,
- short类型,即2个字节,取值范围从-2 ^ 15~2 ^15-1,
- int类型,即4个字节,取值范围从-2 ^ 31 ~ 2 ^ 31-1,
- long类型,即8个字节,取值范围从-2 ^ 63 ~ 2 ^63-1;
- 浮点数类型可以分为单精度float,即4个字节,-3.4E38 ~ 3.4E38,
- 双精度double,即8个字节,取值范围从-1.79E308 ~ 1.79E308。
Java不支持无符号的、只是正值的整数。
类型宽度范围
名 称 | 宽 度 | 范 围 |
long | 64/8 | -9 223 372 036 854 775 808至9 223 372 036 854 775 807 |
int | 32/4 | -2 147 483 648至2 147 483 647 大约21亿 |
short | 16/2 | -32 768至32 767 |
byte | 8/1 | -128至127 |
字面值
(1)整数字面值默认是int类型
(2)将字面值赋给byte或short变量时,如果字面值位于目标类型的范围之内,就不产生错误。
(3)大写或小写的L明确地标识其类型为long
(3)在字面值可以包含下划线,例如1_000_000_000
(4)十进制、八进制(0)、十六进制(0X/0x)、二进制(0B/0b)
注意:
- 虽然小数的取值范围非常的大,但是无法将所有小数都存储进去,因为小数存在着无限不循环小数和无限循环小数
- 同样是4/8字节,但是小数类型存储的范围要大于整数类型,原因是存储形式不一样
- 在处理金融相关的项目时,小数的计算要求是非常的高的,那么使用float和double计算的话都可能出现问题,这时可以使用BigDecimal。
1.12浮点型
浮点数,也称为实数(real number),当计算需要小数精度的表达式时使用。
类型、宽度、范围
名称 | 宽度(位) | 大致范围 |
double(双精度) | 64/8 | 4.9e-324~1.8e+308 |
float (单精度) | 32/4 | 1.4e-045~3.4e+038 |
浮点数字面值
(1)默认为double类型,为了指定float字面值,需要使用后缀F或f
(2)科学计数法。例如6.022E23、314159E-5、2e+100
案例2.2 浮点型案例
1.2 字符型
字符型的大小通常为2个字节
char类型与字符编码
(1)char是16位,Java在内部使用16位的整数表示字符(Unicode编码),char类型的范围0~65536。//全世界基本的语言符号基本都包含了
(2)char也可以用作整数类型,可以将整型字面值赋给char类型的变量,可以在char类型上执行算术运算。
(3)26个小写字母、26个大写字母、以及10个数字0-9,其编码是连续的。
char类型字面值
(1)字符型字面值使用单引号中的字符表示,例如’a’。
(2)转义字符
转义序列 | 描 述 |
\ddd | 八进制字符(ddd) |
\uxxxx | 十六进制Unicode字符(xxxx) |
\’ | 单引号 |
\” | 双引号 |
\ | 反斜杠 |
\r | 回车符 |
\n | 新行符(也称为换行符) |
\f | 换页符 |
\t | 制表符 |
\b | 回格符 |
字符串类型:
字符串类型是String,String是类,所以是引用类型。字符串字面值是使用双引号包围起来的内容。
案例2.3 字符型案例
1.3布尔型
布尔型的分类可以分为true或者false两大类。
(1)boolean类型表示逻辑值,它只能是true或false。
(2)boolean类型的值与整数0和1没有任何关系
(四)引用数据类型
- 类(class)
- 接口(interface)
- 数组([ ])
注意
整数和小数取值范围大小关系:
double > float > long > int > short > byte
(五) 变量常量
1.变量与常量及其方法
1.1变量的声明与赋值
说明:变量表示存储单元,变量名就是存储单元的名称,变量初始化之后就可以通过变量名访问存储单元。
1、变量声明 int i; String str; //还没有分配存储空间
2、初始化(赋初值) i=10; str=”abc”; //初始化之后就分配了存储空间
3、声明并赋值 int i = 10; String str=”abc”; //声明的同时进行初始化
注意:变量在使用之前必须先初始化(赋初值)。
1.2常量的声明与赋值
声明常量需要使用final关键字,如,final double PI = 3.1415926。
常量通常在声明时赋值,并且赋值之后其值不能改变
常量标识符通常全部为大写。
(六)运算符
1.关系运算符
关系运算符也称为比较运算符
运算符 | 结 果 |
== | 等于 |
!= | 不等于 |
> | 大于 |
< | 小于 |
>= | 大于等于 |
<= | 小于等于 |
(1)关系运算的结果为boolean型数值。
(2)关系运算符最常用于if语句和各种循环语句中的控制表达式。
判断一个字符是否是小写字母、大写字母、数字
2.逻辑运算符
布尔逻辑运算符,只能操作boolean型操作数。
运算符 | 结 果 |
&& | 逻辑与(短路形式) |
|| | 逻辑或(短路形式) |
^ | 逻辑异或 |
! | 逻辑一元非 |
& | 逻辑与 |
| | 逻辑或 |
布尔逻辑运算规则:
操作数 | 逻辑运算及结果 | ||||
A | B | A || B | A && B | !A | A ^ B |
false | false | false | false | true | false |
true | false | true | false | false | true |
false | true | true | false | true | true |
true | true | true | true | false | false |
运算规则说明:
对于||,只要有一个操作数为true,则结果为true;
对于&&,只要有一个操作数为false,则结果为false。
对于^,两个操作数不同,则结果为true,否则结果为false。
注意:&&和||,
这两个运算符是所谓短路形式的逻辑运算符。假如单独根据左操作数就能确定表达式的结果,那么就不会计算右操作数的值。
短路逻辑案例
演示短路逻辑表达式的求值过程
int a = 5;
int b = 6;
if(a < b || ++a == b) {
//通过第一部分就能确定最终结果的话,第二部分就不会执行
System.out.println(a);
}//分别使用 | 和 || 测试效果(输出a的值)
3.位运算符(了解)
左移与右移
1000 0010
(1)左移<<:低位补0,左移动1位,相当于乘以2
(2)右移>>:高位补符号位,右移1位,相当于除以2
(3)无符号右移>>>:高位补0
4. 位逻辑运算符
运算符 | 结 果 |
~ | 按位一元取反 |
& | 按位与 |
| | 按位或 |
^ | 按位异或 |
运算规则:
操作数 | 位运算及结果 | ||||
A | B | A| B | A& B | A ^ B | ~A |
0 | 0 | 0 | 0 | 0 | 1 |
1 | 0 | 1 | 0 | 1 | 0 |
0 | 1 | 1 | 0 | 1 | 1 |
1 | 1 | 1 | 1 | 0 | 0 |
注意:
&和|,如果操作数为boolean类型,则为逻辑运算符,如果操作数为整数则为位运算符。通常将&和|作为位运算符。
位运算符与赋值运算符的结合
例如:a >>= 4; 相当于a = a >> 4;
示例3.10 位运算案例
演示<<、>>以及>>>
演示位逻辑运算
5.三目运算符(三元)
运算规则
表达式1 ? 表达式2: 表达式3
语法:表达式1?表达式2:表达式3
表达式1必须是boolean类型的表达式
如果结果为true,那么取表达式2的结果
如果结果为false,那么取表达式3的结果
int aa = 24;
int bb = 23;
int r = aa>bb?3:4;
System.out.println("r = "+r);
6.大概顺序
算术运算符>移位运算符>关系运算符>逻辑运算符>赋值运算符
圆括号会提升其内部操作数的优先级。为了得到所期望的结果,这通常是必需的。圆括号(不管是否冗余)不会降低程序的性能。所以,为了减少模糊性而添加圆括号,不会对程序造成负面影响。
(七) 实例变量与局部变量
1.实例变量及作用范围
根据变量声明的位置,变量可以分为实例变量和局部变量。
在类的{}内直接定义的变量,称为全局变量。
作用范围:整个类中都可以使用
实例变量在创建对象时会自动初始化,并有初始值(默认值)
byte/short/int:0
long:0L
float:0.0f
double:0.0
boolean:false
引用类型:null
2.局部变量及作用范围
在方法中或代码块{ }中定义的变量,称之为局部变量。
作用范围:直接包含它的{}内有效
局部变量不会自动初始化,没有默认值,使用之前必须要初始化。
(八)类型转换
Java中类型转换分自动类型转换和强制类型转换。
总结:对于数值类型,如果目标类型的范围包含了原类型的范围,则可以自动转换,否则就需要强制转换。
1.自动类型转换
类型兼容、小类型转换为大类型
byte-->int short--->int int--->long
long--->float float--->double
String--->Object (子类--->父类)
2.强制类型转换
大类型转换为小类型
int-->byte int--->short long--->int
float--->long double--->float
Object--->String
(九)运算符
可以将大部分Java运算符划分为四组:算术运算符、位运算符、关系运算符以及逻辑运算符。
1.赋值运算符
赋值运算符有一个有趣的特性:它允许创建赋值链。例如,分析下面的代码段:
int x, y, z;
x = y = z = 100; // set x, y, and z to 100
2.算术运算符
算术运算符用于数学表达式,其使用方法与在代数中的使用方法相同。
运算符 | 结 果 |
+ | 加法(也是一元加号) |
- | 减法(也是一元负号) |
* | 乘法 |
/ | 除法 |
% | 求模/取余 |
+= | 加并赋值 |
-= | 减并赋值 |
*= | 乘并赋值 |
/= | 除并赋值 |
%= | 求模并赋值 |
++ | 自增 |
-- | 自减 |
需要注意的地方:
(1)当将除法运算符用于整数类型时,其结果不会包含小数部分。
(2)求模运算符%,返回除法操作的余数。它既可以用于浮点数也可以用于整数。可以用于判断一个整数是否是奇数、偶数、是否是某个数的倍数。
演示算术运算,特别注意是整除,演示除0效果
判断一个数是奇数还是偶数
判断一个数是否是5的倍数…
输入一个三位数,分别获取个、十、百位上的数字。123
3.算术与赋值复合运算符
int a = 1;
a += 2; //相当于a = a+2;
(1)对于所有的二元算术运算,都有相应的复合赋值运算符。
(2)复合赋值运算符的效率更高。所以在专业的Java程序中,会经常看到复合赋值运算符。
4.自增与自减
(1)自增运算符将其操作数加1。自减运算符将其操作数减1。
(2)自增与自减分前缀形式与后缀形式。++、--
前缀形式:
int i = 10;
int a = ++ i; //等同于 i++; int a = i; 所以a=11, i= 11
后缀形式:
int j = 10;
int b = j++; //等同于 int b = j; j++; 所以b=10,j = 11
重点演示前缀与后缀形式的区别。
5.表达式
(1)表达式的概念:由操作数与运算符组成 j++; a+b;
(2)表达式的求值:表达式是有值的,需要注意表达式值的类型
(3)表达式中的类型提升规则:
表达式的类型会自动提升为所有操作数的最大类型。
对于操作数全为非long类型整数的表达式,其类型会自动提升为int。
演示类型自动提升
(十)流程控制-选择结构
顺序结构 一行一行顺序执行
选择结构 有选择的执行
循环结构 一行按照循环条件执行
选择结构是通过分支语句实现的,分支语句有两种。
1. if-else
if语句的三种形式
格式1
package com.yupy03;
public class Oeder {
public static void main(String[] args) {
//System.out.println("开始");
//int a = 20; int b = 20;
//if(a==b){
//System.out.println("执行此行语句体");
//}
格式2
public class Oeder {
public static void main(String[] args) {
System.out.println("开始");
int a = 20; int b = 20;
if(a==b){
System.out.println("执行此行语句体");
}
int c = 43;
if(c%2==0){
System.out.println("c是偶数");
}else{
System.out.println("c是奇数");
}
System.out.println("结束");
格式3
import java.util.Scanner;//导入键盘录入包
public class Oeder {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入温度:");
int qiWen = sc.nextInt();//获取键盘录入数据
if(qiWen>=30 && qiWen<=40){
System.out.println("温度在30~40度适合穿短袖或背心");
}else if(qiWen>=20 && qiWen<=29){
System.out.println("温度在20~29度适合穿卫衣和外套");
}else if(qiWen>=10 && qiWen<=28){
System.out.println("温度在10~28度适合穿毛衣或者外套");
}else if(qiWen>=-20 && qiWen<=9){
System.out.println("温度在-20~9度适合穿袄子厚外套");
}else
System.out.println("您输入的数值不正确!!!!!");
}
}
注意:
else 不能单独使用,要和if配对使用
if else 都可以后面不跟{},但是只能控制下面的一行代码
2.多分支语句switch
switch语句的结构
switch (expression) {
case value1:
// statement sequence
break;
case value2:
// statement sequence
break;
...
case valueN :
// statement sequence
break;
default:
// default statement sequence
}
switch语句需要注意的问题
(1)switch(expression)中expression的结果必须是 byte,short,char,int 中的一种。 新增:枚举类型 、String 不可以是long
(2)在同一个switch语句中,两个case常量不允许具有相同的值
(3)每个case语句中需要加上break;语句。如果遗漏了break,则会继续进入到下一个case。
(4)可以省略default语句。
(5)default语句通常放在末尾,可以放在开始,中间或者末尾位置。
switch案例
输入1-7之间的数字表示一周的中的第几天,输出对应的星期几。
if-else与Switch的区别
(1)switch语句只能进行相等性测试,这一点与if语句不同,if语句可以对任何类型的布尔表达式进行求值。即,switch只查看表达式的值是否和某个case常量相匹配。
(2)相对于一系列嵌套的if语句,switch语句通常效率更高。
(3) switch能做的分支,if...else...一定能做。但是if...else...能做的分支,switch不一定能做。
(十一) 控制语句
选择语句(分支语句)、迭代语句(循环语句)、跳转语句
1. while循环结构
while(condition) {
// body of loop
}
一般在循环体内控制循环的结束条件:让循环条件为false或break
2.do while循环结构
do {
// body of loop
} while (condition);
至少执行一次循环。
示例:
分别使用while和do-while循环计算1-100的和
While和do while的区别
do while先执行 后判断 所以它至少执行一次
while先判断条件 再执行 有可能一次也不执行
所有的循环,都可能出现死循环
3.for循环结构
语法
for(initialization; condition; iteration) {
// body
}
四个部分:初始化部分A、循环条件B、循环体D、迭代部分C
A只执行一次。
执行B判断真假,如果真T,执行D,然后再执行C变量变化
演示案例:
使用for循环计算1-100的和
嵌套的for循环
循环是可以嵌套的,包括while和do-while循环
使用两个变量控制循环**
for(int i=0, j=10; i<j; i++,j--){
//输出i和j的值
}
案例:输入两个数,查找两个数的中间数
练习总结:
学生基本语法可以掌握,稍有逻辑不会,建议多做稍有逻辑练习题
例如:
i%2==0 知道是2的整倍数的判断 基本语法没问题
判断一个数字i 能否被2 到(i-1)任意一个整除,就不会了。
4.break和continue
break:终止直接包含的循环体,结束(本层)循环
continue:跳过本次循环,直接执行循环的下一次 return相当于
(十二)数组的概念
一个具有固定大小,可以容纳相同类型数据的集合.
数组元素的类型:可以是基本类型,也可以是引用类型
数组可以认为是Java中最简单的复合类型。
数组的声明和使用,在语法上与C语言类似,但是在内部实现机制上有本质的区别。
1.数组声明
两种方式:强烈建议采用第一种方式
int[] nums; 或
int nums[];
2.数组创建与初始化
2.1 使用new创建数组
int[] nums; //声明数组,并没有创建数组,没有开辟堆内存。
nums = new int[5]; //创建数组,必须设置长度 开辟堆内存
new:用于分配内存的特殊运算符。通过new分配的数组,其元素会被自动初始化为0(对于数值类型)、false(对于boolean类型)或null(对于引用类型)。
说明:获得一个数据需要两个步骤,第一步是声明,第二步是创建数组对象。
一个数组就是一个对象。数组是动态创建的,所有对象都是动态创建的。
2.2创建数组的三种方式
int[] nums = new int[5]; //初始化为默认值
int[] nums = {1,2,3,4,5}; //初始化为{}中指定的值,静态初始化
int[] nums = new int[] {1,2,3,4,5};//初始化为{}中指定的值,静态初始化
2.3创建数组需要注意的问题
1、创建数组时必须知道数组的长度,否则new不知道要开辟多大的内存
2、第二种方式创建数组,必须在声明数组的同时创建数组
3、创建数组之后,数组的长度不能再改变。
说明:
数组的初始化分为静态初始化和动态初始化,静态初始化在初始化时由程序员显示指定每个数组元素的初始值,由系统决定数组长度。
2.4数组操作
1、通过下标访问数组元素:为指定的数组元素赋值、使用数组元素。如果数组下标越界,会抛出异常。
2、通过循环处理数组(打印输出所有数组元素)数组与循环是分不开的
3、可以使用length属性获取数组的长度,从而可以避免数组越界。
示例
创建数组、静态初始化、遍历输出数组元素
//声明数组
int arr[] ;
//创建数组 开辟空间
int arr[] = new int[5];
//遍历排序
for(int i = 0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
示例5.2 随机数生成
使用Math类的random方法,动态初始化
//随机数生成
Random r = new Random();
//生成三个十以内的随机数
for(int i = 0;i<=3;i++){
//调用,记得写小括号里面的范围区间
int a = r.nextInt(10);
System.out.println("有"+a);
}
//生成1~n以内的随机数
int n = 50;
int num = r.nextInt(n)+1;//1~n之间的
System.out.print(num);
- 课后总结
package day01;
public class Day1 {
//数组排序
public static void main(String[] args) {
test();
test1();
}
/**
* Arrays
*/
public static void test() {
int arr[] = {87, 84, 28, 100, 88, 86, 79, 60};
//Arrays.sort(arr);
//多维数组
int arr1[][] = {
{52, 65, 98},
{45, 89, 63},
{45, 78, 96, 30}
};
System.out.println(arr1[1][1]);
//三维数组
int arr2[][][] = {
{{33, 45, 6989, 56}, {77, 89, 69}, {78, 42, 36}},
{{1, 2}, {3, 5}, {4, 9}},
{{8, 63}, {78, 65}, {78, 69}}
};
}
public static void test1() {
int arr[] = {87, 84, 28, 100, 88, 86, 79, 60};
//冒泡排序:相邻两两比较,数组从一开始
for (int i = 0; i < arr.length - 1; i++) {//层数少一 0 1 2 3 4 5 6 一共七层
//内层循环排序 比较次数:7 6 5 4 3 2 1 得法:长度8-1-i 也就是找规律
for (int j = 0; j < arr.length - 1 - i; j++) {
//arr[j]a<rr[j+1] 从大到小
if (arr[j] > arr[j + 1]) {//从小到大
//先把第一个数放空盒子里
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
//遍历排序
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}
- 课后总结2
package day01;
public class Day1Test {
public static void main(String[] args) {
System.out.println("12345789");
add(5,5);//方法调用要匹配
System.out.println(add1(5,9));
//int n =add1(5,9);
//System.out.println("和为:"+n);
add2(2,"白熊");
add3(6,8);//循环
get();
}
//void代表空,该方法没有返回值
public static void add(int n,int i){
System.out.println("我是白熊");
System.out.println("i+n"+"="+(i+n));
}
public static int add1(int n,int i){
return i+n;//定义返回值int类型,对应
}
public static void add3(int n,int i) {
//返回值返回类型
return;//跳出该方法,返回到调用的地方
//return后面的所有语句都不执行
// System.out.println("白熊");//会报错
}
public static void add2(int n,String i){
System.out.println("我是阿晨");
}
public static void get(){
System.out.println("我是二小");
}
}
3.冒泡排序
简介(从小到大排序) 比较相邻的元素。如果第一个比第二个大,就交换他们两个。对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。针对所有的元素重复以上的步骤,除了最后一个,即需要进行length-1次。
第一次是对n个数进行n-1次比较,进行到最后第n个的一个是最大的;
第一次是对n个数进行n-1次比较,进行到最后第n个的一个是最大的;
......
持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
代码实现
//要求:输入五个学生成绩,排序遍历
int arr[] = {96, 69, 89, 44, 88};
for(int i = 0;i<arr.length-1;i++){//层数
for(int j = 0;j<arr.length-1-i;j++){//内层排序,数组下标从0开始
if(arr[j]>arr[j+1]){//判断大小
int temp = arr[j];//空盒子存放
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
//遍历排序
for(int i = 0;i<arr.length;i++){
System.out.print(arr[i]+" ");
}
4.Arrays.sort()方法
代码实现
public static void test5(){
Scanner sc = new Scanner(System.in);
//定义arr为容量为5的数组放学生成绩
int arr[] = new int[5];
for (int i = 0; i < arr.length; i++) {
System.out.println("请输入第"+(i+1)+"位学生的成绩:");
arr[i] = sc.nextInt();
}
System.out.print("初始成绩为: ");
for(int i = 0;i<arr.length;i++) {
System.out.print(arr[i] +" ");
}
//使用方法
Arrays.sort(arr);
//方法二:使用Arrays.sort(int[] a, int fromIndex, int toIndex)-->取左不取右,下标表示
//Arrays.sort(arr,0,5);
System.out.println();
System.out.print("排序后成绩为: ");
for(int i = 0;i<arr.length;i++) {
System.out.print(arr[i] +" ");
}
}
}
基本选择器● 基本选择器是 jQuery 中最常用的选择器, 也是最简单的选择器, 它通过元素 id, class
和标签名来查找 DOM 元素
1、#id 用法:
$("#myDiv");
返回值 单个元素的组成的集合
说明: 这个就是直接选择 html 中的 id=”myDiv”
2、Element 用法:
$("div")
返回值集合元素
说明: element 的英文翻译过来是”元素”,所以 element 其实就是 html 已经定义的标签元素,例如 div, input, a 等等.
3、class 用法:
$(".myClass")
返回值集合元素
说明: 这个标签是直接选择 html 代码中 class=”myClass”的元素或元素组(因为在同一html 页面中 class 是可以存在多个同样值的).
4、* 用法:
$("*")
返回值集合元素
说明: 匹配所有元素,多用于结合上下文来搜索
5、selector1, selector2, selectorN 用法:
$("div,span,p.myClass")
返回值 集合元素
说明: 将每一个选择器匹配到的元素合并后一起返回.你可以指定任意多个选择器, 并将匹配到的元素合并到一个结果内.其中 p.myClass 是表示匹配元素 p class=”myClass”
● 基本选择器应用实例
- 改变 id 为 one 的元素的背景色为 #0000FF
- 改变 class 为 mini 的所有元素的背景色为 #FF0033
- 改变元素名为 <div> 的所有元素的背景色为 #00FFFF
- 改变所有元素的背景色为 #00FF33
- 改变所有的<span>元素和 id 为 two 的元素的背景色为 #3399
程序运行图
div.mini {
width: 60px;
height: 30px;
background: #CC66FF;
border: #000 1px solid;
font-size: 12px;
font-family: Roman;
}
</style>
<script type="text/javascript" src="./script/jquery-3.6.0.min.js"></script>
<script type="text/javascript">
$(function () {
//1. 改变 id 为 one 的元素的背景色为 #0000FF
$("#b1").click(
function () {
$("#one").css("background", "#0000FF");
}
)
//2. 改变 class 为 mini 的所有元素的背景色为 #FF0033
$("#b2").click(
function () {
$(".mini").css("background", "#FF0033");
}
)
//3. 改变元素名为 <div> 的所有元素的背景色为 #00FFFF
$("#b3").click(
function () {
$("div").css("background", "#00FFFF");
}
)
//4. 改变所有元素的背景色为 #00FF33
$("#b4").click(
function (){
$("*").css("background", "#00FF33");
}
)
//5. 改变所有的<span>元素和 id 为 two class为 .mini 的元素的背景色为 #3399FF
$("#b5").click(
function (){
$("#two,.mini,span").css("background", " #3399FF");
}
)
})
</script>
层次选择器● 如果想通过 DOM 元素之间的层次关系来获取特定元素, 例如后代元素, 子元素, 相邻元素, 兄弟元素等, 则需要使用层次选择器.
1 、ancestor descendant
用法: $(”form input”) ;
返回值 集合元素
说明: 在给定的祖先元素下匹配所有后代元素.这个要下面讲的”parent > child”区分开.
2、parent > child
用法:
$(”form > input”) ;
返回值 集合元素
说明: 在给定的父元素下匹配所有子元素.注意:要区分好后代元素与子元素
3、prev + next
用法:
$(”label + input”) ;
返回值 集合元素
说明: 匹配所有紧接在 prev 元素后的 next 元素
4、prev ~ siblings
用法:
$(”form ~ input”) ;
返回值 集合元素
说明: 匹配 prev 元素之后的所有 siblings 元素.
注意:是匹配之后的元素,不包含该元素在内,并且 siblings 匹配的是和 prev 同辈的元素,其后辈元素不被匹配.
注意: (“prev ~ div”) 选择器只能选择 “# prev ” 元素后面的同辈元素; 而 jQuery中的方法 siblings() 与前后位置无关, 只要是同辈节点就可以选取
● 层次选择器应用实例
div.mini {
width: 80px;
height: 30px;
background: #CC66FF;
border: #000 1px solid;
font-size: 12px;
font-family: Roman;
}
</style>
<script type="text/javascript" src="./script/jquery-3.6.0.min.js"></script>
<script type="text/javascript">
$(function () {
//1. 改变 <body> 内所有 <div> 的背景色为 #0000FF
$("#b1").click(function () {
$("div").css("background", "#0000FF");
})
//2. 改变 <body> 内子 <div>[第一层div] 的背景色为 #FF0033
$("#b2").click(
function () {
$("body > div").css("background", "#FF0033");
}
)
//3. 改变 id 为 one 的下一个 <div> 的背景色为 #0000FF
$("#b3").click(
function (){
$("#one + div").css("background", "#0000FF");
}
)
//4. 改变 id 为 two 的元素后面的所有兄弟<div>的元素的背景色为 # #0000FF
$("#b4").click(
function () {
$("#two ~ div").css("background", "#0000FF");
}
)
//5. 改变 id 为 two 的元素所有 <div> 兄弟元素的背景色为 #0000FF
$("#b5").click(
function (){
$("#two").siblings("div").css("background", "#0000FF");
}
)
})
</script>
</head>
<body>
<input type="button" value="改变 <body> 内所有 <div> 的背景色为 #0000FF" id="b1"/>
<input type="button" value="改变 <body> 内子 <div> 的背景色为 #FF0033" id="b2"/>
<input type="button" value=" 改变 id 为 one 的下一个 <div> 的背景色为 #0000FF" id="b3"/>
<input type="button" value=" 改变 id 为 two 的元素后面的所有兄弟<div>的元素的背景色为 # #0000FF" id="b4"/>
<input type="button" value=" 改变 id 为 two 的元素所有 <div> 兄弟元素的背景色为 #0000FF" id="b5"/>
<hr/>
<div id="one" class="mini">
div id为one
</div>
<div id="two">
div id为two
<div id="two01">
id two01
</div>
<div id="two02">
id two02
</div>
</div>
表单选择器● 表单选择器基本介绍1、:input 用法:
$(":input")
; 返回值 集合元素
说明:匹配所有 input, textarea, select 和 button 元素
2、:text 用法:
$(":text") ;
返回值 集合元素
说明: 匹配所有的单行文本框.
3、:password 用法:
$(":password") ;
返回值 集合元素
说明: 匹配所有密码框.
4、:radio 用法:
$(":radio") ;
返回值 集合元素
说明: 匹配所有单选按钮.
5、:checkbox 用法:
$(":checkbox")
; 返回值 集合元素
说明: 匹配所有复选框
6、:submit 用法:
$(":submit")
; 返回值 集合元素
说明: 匹配所有提交按钮.
7、:image 用法:
$(":image")
返回值 集合元素
说明: 匹配所有图像域.
8、:reset 用法:
$(":reset") ;
返回值 集合元素
说明: 匹配所有重置按钮.
9、:button 用法:
$(":button") ;
返回值 集合元素
说明: 匹配所有按钮.这个包括直接写的元素 button.
10、:file 用法:
$(":file") ;
返回值 集合元素
说明: 匹配所有文件域.
11、:hidden 用法:
$("input:hidden") ;
返回值 集合元素
说明: 匹配所有不可见元素,或者 type 为 hidden 的元素.这个选择器就不仅限于表单
了,除了匹配 input 中的 hidden 外,那些 style 为 hidden 的也会被匹配.
注意: 要选取 input 中为 hidden 值的方法就是上面例子的用法,但是直接使用":hidden" 的话就是匹配页面中所有的不可见元素,包括宽度或高度为 0 的
代码演示
//得到type="button" 的元素
//$("input[type='button']") 只会得到 <input type="button" value="按钮1"/>
var $button2 = $("input[type='button']");
alert("$button2 大小=" + $button2.length)//1
//得到<button />按照元素标签取值
//$("button") 只会按照元素标签获取 <button>按钮2</button>
var $button3 = $("button");
alert("$button3 大小=" + $button3.length)//2
});
</script>
</head>
<body>
<form>
<input type="text"/><br/>
<input type="checkbox"/><br/>
<input type="radio"/><br/>
<input type="image" src="../image/2.png" height="100"/><br/>
<input type="file"/><br/>
<input type="submit"/><br/>
<input type="reset"/><br/>
<input type="password"/><br/>
<input type="button" value="按钮1"/><br/>
<select>
<option/>
</select><br/>
<textarea></textarea><br/>
<button>按钮2</button>
<button>按钮3</button>
<br/>
</form>
</body>
</html>
综合代码示例网页中所有的元素添加 onclick 事件
- 需求: 网页中所有的元素添加 onclick
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>网页中所有的 <p> 元素添加 onclick 事件</title>
<script type="text/javascript" src="../script/jquery-3.6.0.min.js"></script>
<script type="text/javascript">
$(function (){
//方式1
//1. 选择器选择p元素-基础选择器
//2. 绑定事件-函数-获取p元素的文本
//3. 统一绑定.
$("p").click(function (){
//3. 当我们点击p元素时, 会隐式的传入this(dom), 表示你当前点击的p
// 元素,对应的dom对象
//alert("p的内容是= " + this.innerText)
alert("p的内容是(jquer方式)=" + $(this).text())
})
//方式2
//对所有的p元素进行遍历
//遍历执行内部function 依然会隐式的传入this(表示当前的p的dom对象)
//这是遍历出一个p对象, 就绑定一个click事件
$("p").each(function (){
$(this).click(function (){
alert("p的内容~=" + $(this).text())
})
})
})
</script>
</head>
<body>
常规选择器:
1、$('#box') ID选择器,获取一个ID为box的DOM对象
2、$('.box') CLASS选择器,获取一个class为box的DOM对象
3、$('div') 元素名选择器,获取一个元素名为div的DOM对象
进阶选择器:
1、$('div,#box,.box') 群组选择器,获取元素名为div、ID为box、class为box的DOM对象
2、$('div #box') 后代选择器,获取div中ID为box的DOM对象 另一种写法$('div').find('#box')
3、$('*') 通配选择器,获取HTML中的所有元素的DOM对象
高级选择器:(IE6不支持)
1、$('div > p') 子选择器,获取div下子元素为p的DOM对象 另一种写法$('div').children('p')
2、$('div + p') next选择器,获取div后面第一个 同级 P元素的DOM对象 另一种写法$('div').next('p')
3、$('div ~ p') nextAll选择器,获取div后面所有 同级 p元素的DOM对象 另一种写法$('div').nextAll('p')
4、$('div').prev('p') 获取div前面最近 同级 P元素的DOM对象
5、$('div').prevAll('p') 获取div前面所有 同级 p元素的DOM对象
6、$('div').nextUntil('p') 获取div后面所有 同级 元素对象,遇到p元素停止
7、$('div').prevUntil('p') 获取div前面所有 同级 元素对象,遇到p元素停止
8、$('div').siblings('p') 获取div前后所有 同级 p元素
属性选择器:
1、$('div[name = user]') 获取name=user的div元素的DOM对象
过滤选择器:
1、基本过滤器:
(1)$('li:first') 选取第一个元素 另一种写法$('li').first()
(2)$('li:last') 选取最后一个元素 另一种写法$('li').last()
(3)$('li:not(#box)') 选取ID不是box的li元素 另一种写法$('li').not('#box')
(4)$('li:even') 选取索引是偶数的所有元素
(5)$('li:odd') 选取索引是奇数的所有元素
(6)$('li:eq(2)') 选取索引等于2的元素 另一种写法$('li').eq(2)
(7)$('li:gt(2)') 选取索引大于2的元素
(8)$('li:lt(2)') 选取索引小于2的元素
(9)$('li:header') 选取标题元素h1~h6
(10)$('li:animated') 选取正在执行动画的元素
(11)$('li:focus') 选取当前被焦点的元素
2、内容过滤器:
(1)$('div:contains("text")') 选取内容含有“text”的div元素
(2)$('div:enpty') 选取不包含子元素或空文本的div元素
(3)$(div:has(#box)) 选取子元素含有ID为box的div元素
(4)$('div:parent') 选取含有子元素或文本的div元素
(5)$('li').parent() 选择当前元素的父元素
(6)$('li').patents() 选择当前元素的祖先元素
(7)$('li').parentsUntil('div') 选择当前元素的祖先元素直到遇到div为止
3、可见性过滤器:
(1)$('div:hidden') 选取隐藏的div元素
(2)$('div:visible') 选取可见的div元素
4、子元素过滤器:
(1)$('li:first-child') 选取每个父元素的第一个li元素
(2)$('li:last-child') 选取每个父元素的最后一个li元素
(3)$('li:only-child') 选取每个父元素只有一个li元素
(4)$('li:nth-child(2n)') 选取每个父元素的第一、三、五……个li元素
5、其他方法
.is('li') 判断是否是同一个元素,返回boolean
.hasClass('.red') 判断是否有class值为***的元素,返回boolean
.slice(start,end) 获取索引为start到索引为end的元素
.filter()
.end() 获取当前元素的前一次状态
.contains() 获取元素下面的所有节点