命名规则:标识符可以有字母、数字、下划线( _ )和美元符( $ )组成,不能以数字开头。严格区分大小写、不能是Java关键字和保留字。
关键字:Java中的关键字是对编译器有特殊意义的词。比如class是用来定义类的关键字,编译器遇到class就知道这是定义了一个类
保留字:保留字是Java预留的关键字,虽然现在还没有作为关键字,但是以后升级版本中会成为关键字(包括:goto、const)
变量存储在内存当中。
变量的三个元素:
//变量类型 变量名 变量值
String name = "Jack";
age
则所有字母都小写,若多个单词组成学生姓名:stuName
则第一个单词全部小写后面的单词首字母大写。age
、stuName
HelloImooc
数据类型分为:基本数据类型和引用数据类型
基本数据类型分为三大类:
字符型:所有在键盘能输入的内容都叫字符。
布尔型:分为true和false,true代表真false代表假。
数值型分为两大类:整数类型和浮点类型。
数据转换分为自动类型转换和强制类型转换。
char a = (char)65536; //强制类型转换会引起数据丢失。
常量就是在变量前面加一个final
,用final
来定义常量。
final double PI = 3.14;
通常final
修饰的常量无法再次赋值。
错误原因:final关键字修饰的常量是无法再进行赋值,否则会出现途中的编译错误。
常量一般用大写字母表示,一个单词用大写表示,多个单词中间用
_ 下划线
进行连接。
public class FinalDome {
public static void main(String[] args){
final int PI=14; //一个单词用大写表示
final int MIN_VALUE=1; //多个单词中间用_“下划线”链接
}
}
字符型字面值使用单引号内的单个字符表示,单引号里变必须是英文状态下的字符,并且用单引号圈起来否则报错。
使用7位或8位二进制数组合类表示128或256中可能的字符。
如果用7位二进制数组合—–是标准的ASCII码
如果用8位二进制数(后128位)—–属于扩展ASCII码
char a=’\u005d’;
Unicode表示法,在之前面加前缀\u。
布尔值只能定义true或false。例如:boolean a=true;
字符串不属于基本数据类型,它是类。但是它有一些类型和基本数据类型比较类似的地方:比如定义的形式。
字符串字面值的表示方法:双引号引起来的0个或多个字符。String a=””;
由运算符和操作数组成的。
算数运算符、赋值运算符、关系运算符、逻辑运算符、条件运算符、位运算符。
public class MathDemo {
public static void main(String[] args){
int num=15,num1=3;
int result;//存放结果
//加法
result=num+num1;
System.out.println(num+"+"+num1+"="+result);
//字符串链接: 前边没有加引号进行的树脂运算,加引号用的是字符串链接运算。
System.out.println(""+num+num1);
//减法
result=num-num1;
System.out.println(num+"-"+num1+"="+result);
//乘法
result=num*num1;
System.out.println(num+"*"+num1+"="+result);
//除法
result=num/num1;
System.out.println(num+"/"+num1+"="+result);
System.out.println(15/4);//分子分母都是整型时都是整除后的结果
System.out.println("15.0/4"+"="+15.0/4);
//求余数
result=11%num1;
System.out.println(11%+num1+"="+result);
System.out.println("11.5%3"+"="+(11.5%3));
}
}
public class MathDemo1 {
public static void main(String[] args) {
//x++
int x=4;
int y=(x++)+5;
System.out.println("x="+x+",y="+y);
//++x
x=4;
y=(++x)+5;
System.out.println("x="+x+",y="+y);
//x--
x=4;
y=(x--)+5;
System.out.println("x="+x+",y="+y);
//--x
x=4;
y=(--x)+5;
System.out.println("x="+x+",y="+y);
}
}
注意:赋值运算是从右往左运算。如:
int n=3;
将3赋值给n
比较运算符用于比较两个数值的大小,比较的结果是一个布尔值。
if (条件){
<语句块>
}
if (条件) {
<语句块>
} else {
<语句块>
}
运算符 | 含义 | 效果 |
---|---|---|
&& | 与 | 将两个表达式连接成一个。两个表达式必须都为 true,整个表达式才为 true |
|| | 或 | 将两个表达式连接成一个。必须有一个或两个表达式为 true,才能使整个表达式为 true。只要其中有一个为 true,那么另外一个就变得无关紧要 |
! | 非 | 反转一个表达式的“真相”。它使一个表达式从 true 变成了 false,或者从 false 变成了 true |
&&
运算符又叫短路运算符,当第一个表达式的值能决定最后的结果,运算符右边的表达式就不再计算。boolean b=(3>7)&&(4<2);
||
运算符又叫短路运算符,当第一个表达式的值能决定最后的结果,运算符右边的表达式就不再计算。
!运算符:对原条件取反。真 ==>假 \ 假 ==>真
Java中的条件运算符是三目运算符。(++
是单目运算符、+ - * /
是双目运算符。)
语法:布尔表达式?表达式1:表达式2
,当布尔表达式为true的时候返回表达式1的值,当布尔表达式为false的时候返回表达式2的值。
public class ConditionDemo {
public static void main(String[] args){
int a=5,b=10;
//比较a和b的大小!
int max;//存放最大值
if (a>b){
max=a;
}else{
max=b;
}
System.out.println("max="+max);
max = a > b ? a : b;
System.out.println("max="+max);
boolean b1 = a > b ? (2 < 4) : (true == false);
System.out.println("max="+b1);
}
}
public class ScoreAssess {
public static void main(String[] args){
System.out.print("请输入成绩:");
Scanner sc = new Scanner(System.in);
int score=sc.nextInt();
if (score >90){
System.out.println("优");
}else if (score>=80){//相当于score>=80 &score<90
System.out.println("良");
}else if (score>=60){
System.out.println("中");
}else {
System.out.println("不及格!");
}
}
}
public class Number {
public static void main(String[] args) {
//输入随机数字
System.out.print("请输入第一个随机数:");
Scanner sc = new Scanner(System.in);
int num1=sc.nextInt();
System.out.print("请输入第二个随机数:");
Scanner sc1 = new Scanner(System.in);
int num2=sc1.nextInt();
//比较两个随机数的大小
if (num1==num2){
System.out.println(num1+"相等"+num2);
}else {
if (num1>num2){
System.out.println(num1+"大于"+num2);
}else{
if (num1<num2){
System.out.println(num1+"小于"+num2);
}
}
}
}
}
if结构:判断条件是布尔类型。判断条件是一个范围。 switch结构:判断条件是常量值。
public class WeekDemo1 {
public static void main(String[] args){
System.out.print("请输入1-7数字:");
Scanner sc = new Scanner(System.in);
int n=sc.nextInt();
switch(n) {
case 1:System.out.println("星期一");break;
case 2:System.out.println("星期二");break;
case 3:System.out.println("星期三");break;
case 4:System.out.println("星期四");break;
case 5:System.out.println("星期五");break;
case 6:System.out.println("星期六");break;
case 7:System.out.println("星期日");break;
default:System.out.println("超出了1-7的范围!");
}
}
}
public class PlusDemo {
public static void main(String[] args){
//求1+3+5+7+9+11----+15的累加和
int n=1,sum=0;
while(n<15){
sum=sum+n;
n=n+2;
}
System.out.println("sum="+sum);
}
}
do-while循环至少执行一次,循环条件后的分号不能丢。 执行顺序:先执行后判断
public class DoWhileDemo {
public static void main(String[] args) {
int n=1,sum=0;
do {
sum+=n;
n++;
}while (n<=5);
System.out.println("sum="+sum);
}
}
For执行顺序:首先会运行表达式1:int n=1
,在循环中只运行一次
public class ForDemo {
public static void main(String[] args){
//打印99乘法表
for (int a=1;a<=9;a++){
for (int b=1;b<=9;b++){
System.out.print(a+"*"+b+"="+(a*b)+"\t");
}
System.out.println();
}
}
}
增强for循环是for的一种新用法!用来循环遍历数组和集合。
增强型For循环又叫ForEach
循环。
for(int e:a){
System.out.println(e)
}
用break语句可以使流程跳出switch语句体,也可以用break语句在循环结构终止本层循环体,从而提前结束本层循环。
使用说明:
(1)只能在循环体内和switch语句体内使用break;
(2)当break出现在循环体中的switch语句体内时,起作用只是跳出该switch语句体,并不能终止循环体的执行。若想强行终止循环体的执行,可以在循环体中,但并不在switch语句中设置break语句,满足某种条件则跳出本层循环体。
continue语句的作用是跳过本次循环体中余下尚未执行的语句,立即进行下一次的循环条件判定,可以理解为仅结束本次循环。
注意:continue语句并没有使整个循环终止。
数组是相同类型的数据按顺序组成的一种引用数据类型。
数据类型[] 数组名; //int[] myIntArray;
数据类型 数组名[]; //int myIntArray[];
语法格式一:先声明后创建。
数据类型[] 数组名; //int[] arr;
数组名 = new 数据类型[数组长度]; //arr = new int[10];
/*创建一个长度为10的数组。*/
语法格式二:声明的同时创建数组。
数据类型[] 数据名 = new 数据类型[数组长度]; //int[] arr = new int[10];
/*创建长度为10的整型数组arr*/
注意:数组长度必须指定。数组在内存中存储
声明的同时给变量赋值,叫做数组初始化。
int[] arr = {1,2,3,4,5,6,7,8,9,10};
语法格式:
//数组名[下标];
int[] a = {1,2,3,4,5,6,7,8,9,10};
注意:下标从0开始。
int[] a={1,2,3,4,5,6,7,8,9,10};
属性length表示长度。如:a.length
public class ArrayDemo2_5 {
public static void main(String[] args){
//定义一个整型数组a并初始化
int[] a={10,6,12,5,15,8};
//循环遍历数组,找出能被3整除的元素并打印输出
for (int i=0;i<a.length;i++){
if (a[i]%3==0){
System.out.println("能被3整除的数组元素为:"+a[i]);
}
}
}
}
二维数组由多个一维数组组成 二维数组有三种形式的声明方法 列数可以省略,行数不能省略
//声明int类型的二维数组
int[][] intArray;
//声明float类型的二维数组
float floatArray[][];
//声明double类型的二维数组
double[] doubleArray[];
创建一个三行三列的int类型的二维数组 intArray=new int[3][3];
//为第2行第3个元素赋值为9
intArray[2][3]=9;
//声明数组的同时并创建
char[][] ch=new char[3][5];
//创建float类型的数组时,只指定行数不指定列数
float[][] fl=new float[3][]; //列数可以省略,行数绝对不能省略。
//每行相当于一个一维数组
floatArray[0]=new float[3]; //一行有3列
floatArray[0]=new float[4]; //一行有4列
floatArray[0]=new float[5]; //一行有5列
int[][] num={{1,2,3},{4,5,6},{7,8,9}};
System.out.println("num第一行第二列的元素为:"+num[0][1]);
System.out.println("num数组的行数:"+num.length);
System.out.println("num数组的列数:"+num[0].length);
//循环输出二维数组的内容
for(int i=0;i<num.length;i++){
for(int j=0;j<num[i].length;j++){
System.out.print(num[i][j]+" ");
}
}
public static void mian(String[] args){}
是一个特殊的方法,它是程序的入口。
在前面我们经常使用到 System.out.println()
,那么它是什么呢?
println()
是一个方法。System
是系统类。out
是标准输出对象。Java方法是语句的集合,它们在一起执行一个功能。
修饰符 返回值类型 方法名(参数类型 参数名){
...
方法体
...
return 返回值;
}
方法包含一个方法头和一个方法体。下面是一个方法的所有部分:
根据方法是否带参数、是否返回值,可分为四类:
public class MethodDemo {
//打印输出星号的方法
public void printStar() {
System.out.println("**************");
}
public static void main(String[] args){
//创建一个MethDemo类的对象myMethDemo
MethodDemo myMethDemo=new MethodDemo();
//实用对象名.方法名() 调用方法
myMethDemo.printStar();
System.out.println("欢迎来到Java的世界!");
myMethDemo.printStar();
}
}
Scanner类方法就是无参有返回值的方法,next()方法,无参有返回值方法,返回值是String类型。
public class Rectangle {
public int area(){
int Chang=50;
int Kuan=10;
int getArea=Chang*Kuan;
//return 返回值,
return getArea;
}
public static void main(String[] args) {
Rectangle re=new Rectangle();
System.out.println("长方形面积:"+re.area());
}
}
public class MaxDemo {
//求最大值
public void max(float a,float b){
float max;
if (a>b){
max=a;
}else{
max=b;
}
System.out.println(a+"和"+b+"最大值:"+max);
}
public static void main(String[] args){
MaxDemo m=new MaxDemo();
//--------------
float a=1.1f,b=1.2f;
m.max(a,b);
//--------------
m.max(1f,3f);
//--------------
}
}
方法不能嵌套定义:在主方法中再定义一个方法。
public class FacDemo {
public int fac(int n){
//求1!2!3!--5!阶乘
int s=1;
for (int i = 1; i <= n; i++) {
s*=i;
}
return s;//返回总数,
}
public static void main(String[] args){
FacDemo FacDemo=new FacDemo();
System.out.println(FacDemo.fac(5));//调用并输出
}
}
例:定义方法,打印输出数组元素的值。
public class ArrayMethod {
//打印输出数组元素的值。
public void printArray(int[] arr){
for (int i=0;i<arr.length;i++) {
System.out.print(arr[i]+" ");
}
System.out.println();
}
public static void main(String[] args) {
//定义数组并初始化
int[] arr={1,2,5,4,3,6,7,1,0};
ArrayMethod pa=new ArrayMethod();
//给arr传递参数
pa.printArray(arr);
}
}
方法名相同,参数列表不同。这里的参数列表不同指的是,参数的数量不同,或者参数的数据类型不同。
public void display(){}
public void display(int n){}
public void display(float n){}
如下两个方法不是重载方法,两个方法只是参数名不同,不满足方法重载条件。
public void display(int n){}
public void display(int d){}
传递两个参数调用方法。有趣的是,方法被调用后,主方法内的值并没有改变。
public class TestVoidMethod {
//传递参数
public void swap(int a,int b){
int temp;
System.out.println("转换前:a="+a+",b="+b);
temp=a;a=b;b=temp;
System.out.println("转换后:a="+a+",b="+b);
}
/*
不用再创建类,可以直接调用swap的代码
*/
public void swap1(){
int a1=1,b1=2;
System.out.println("转换前:a1="+a1+",b1="+b1);
swap(a1,b1);
System.out.println("转换后:a1="+1+",b1="+b1);
}
public static void main(String[] args){
TestVoidMethod tvm=new TestVoidMethod();
tvm.swap1();
}
}
在数组进行传值的时候,会对主方法当中定义的a1[3];
值产生了影响
public class TestVoidMethod1 {
public void updata(int[] a){
a[3] =15;
System.out.print("数组a元素为:");
for (int i:a) {
System.out.print(i+" ");
}
System.out.println();
}
public static void main(String[] args) {
int[] a1={1,2,3,4,5};
TestVoidMethod1 tvm=new TestVoidMethod1();
System.out.print("方法调用前数组a1的元素为:");
for (int n:a1) {
System.out.print(n+" ");
}
System.out.println();
tvm.updata(a1);
System.out.print("方法调用后数组a1的元素为:");
for (int n:a1) {
System.out.print(n+" ");
}
System.out.println();
}
}
在方法声明中,在指定参数类型后加一个省略号(…)
参数列一个方法中只能指定一个可变参数,它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。
可以将数组传递给可变参数,不能将可变参数列表传递给数组。
public class ArgsDemo {
public void search(int a,int... n){
boolean flag=false;
//将n的值循环输出给i
for(int i:n){
if (a==i){
flag=true;break;
}
}
if (flag){
System.out.println("找到了:"+a);
}else{
System.out.println("没找到:"+a);
}
}
public static void main(String[] args){
ArgsDemo ad=new ArgsDemo();
ad.search(3,1,2,3,4,5);//将3赋值给 a ,12345赋值给 可变参数n
int[] a={1,2,3,4,5};//定义数组并初始化
ad.search(3,a);//将数组赋值给可变参数n
}
}
可变参数列表所在的方法是最后被访问的。
public class ArgsDemo3 {
public int plus(int a1,int b1){
System.out.println("不带可变参数列表被调用!");
return a1+b1;
}
public int plus(int... a){
int sum=0;
for(int i:a){
sum+=i;
}
System.out.println("带可变参数列表被调用!");
return sum;
}
public static void main(String[] args) {
ArgsDemo3 ad=new ArgsDemo3();
System.out.println("参数为:"+ad.plus(1,2));
}
}