Java基础篇



一、标识符

命名规则:标识符可以有字母、数字、下划线( _ )和美元符( $ )组成,不能以数字开头。严格区分大小写、不能是Java关键字和保留字。

1.关键字

图片[1]-Java基础篇-HuaのJava之旅

关键字:Java中的关键字是对编译器有特殊意义的词。比如class是用来定义类的关键字,编译器遇到class就知道这是定义了一个类

保留字:保留字是Java预留的关键字,虽然现在还没有作为关键字,但是以后升级版本中会成为关键字(包括:goto、const)

2.变量

变量存储在内存当中。

变量的三个元素:

  1. 变量类型
  2. 变量名
  3. 变量值
//变量类型 变量名 变量值
String name = "Jack";

①.变量名命名规则

  • 驼峰命名法:如果是单个单词年龄:age则所有字母都小写,若多个单词组成学生姓名:stuName则第一个单词全部小写后面的单词首字母大写。
  • 尽量简单,做到见名知意:比如agestuName
  • Java变量名没有长度限制。

②.类名命名规则

  • 满足Pascal(帕斯卡)命名法规范:组成类名的首字母总是要大写HelloImooc

3. 数据类型

数据类型分为:基本数据类型和引用数据类型

图片[2]-Java基础篇-HuaのJava之旅

基本数据类型分为三大类:

  1. 数值型
  2. 字符型(char)
  3. 布尔型(boolean)

字符型:所有在键盘能输入的内容都叫字符。

布尔型:分为true和false,true代表真false代表假。

数值型分为两大类:整数类型和浮点类型。

①.类型转环

数据转换分为自动类型转换和强制类型转换。

char a = (char)65536;  //强制类型转换会引起数据丢失。
图片[3]-Java基础篇-HuaのJava之旅

4.常量

常量就是在变量前面加一个final,用final来定义常量。

final double PI = 3.14;

通常final修饰的常量无法再次赋值。

图片[4]-Java基础篇-HuaのJava之旅

错误原因:final关键字修饰的常量是无法再进行赋值,否则会出现途中的编译错误。

①.常量命名规则

常量一般用大写字母表示,一个单词用大写表示,多个单词中间用_ 下划线进行连接。

public class FinalDome {
    public static void main(String[] args){
        final int PI=14;  //一个单词用大写表示
        final int MIN_VALUE=1;  //多个单词中间用_“下划线”链接
    }
}

5.字符型

字符型字面值使用单引号内的单个字符表示,单引号里变必须是英文状态下的字符,并且用单引号圈起来否则报错。

图片[5]-Java基础篇-HuaのJava之旅

①.ASCLL码

使用7位或8位二进制数组合类表示128或256中可能的字符。

如果用7位二进制数组合—–是标准的ASCII码

如果用8位二进制数(后128位)—–属于扩展ASCII码

图片[6]-Java基础篇-HuaのJava之旅

②.Unicode编码

char a=’\u005d’; Unicode表示法,在之前面加前缀\u。

图片[7]-Java基础篇-HuaのJava之旅

6.布尔类型

布尔值只能定义true或false。例如:boolean a=true;

①.字符串字面值

字符串不属于基本数据类型,它是类。但是它有一些类型和基本数据类型比较类似的地方:比如定义的形式。

字符串字面值的表示方法:双引号引起来的0个或多个字符。String a=””;

图片[8]-Java基础篇-HuaのJava之旅

二、运算符

由运算符和操作数组成的。

图片[9]-Java基础篇-HuaのJava之旅

算数运算符、赋值运算符、关系运算符、逻辑运算符、条件运算符、位运算符。

1.算数运算符

图片[10]-Java基础篇-HuaのJava之旅
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));
    }
}

2.自增自减运算符

图片[11]-Java基础篇-HuaのJava之旅
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);
    }
}

3.赋值运算符

注意:赋值运算是从右往左运算。如:int n=3; 将3赋值给n

图片[12]-Java基础篇-HuaのJava之旅

4.关系运算符

比较运算符用于比较两个数值的大小,比较的结果是一个布尔值。

图片[13]-Java基础篇-HuaのJava之旅

5.if|if…else结构

if (条件){
    <语句块>
}

if (条件) {
    <语句块>
} else {
    <语句块>
}

6.逻辑运算符

运算符含义效果
&&将两个表达式连接成一个。两个表达式必须都为 true,整个表达式才为 true
||将两个表达式连接成一个。必须有一个或两个表达式为 true,才能使整个表达式为 true。
只要其中有一个为 true,那么另外一个就变得无关紧要
反转一个表达式的“真相”。它使一个表达式从 true 变成了 false,或者从 false 变成了 true

①.&&运算符

&&运算符又叫短路运算符,当第一个表达式的值能决定最后的结果,运算符右边的表达式就不再计算。boolean b=(3>7)&&(4<2);

②.||运算符

||运算符又叫短路运算符,当第一个表达式的值能决定最后的结果,运算符右边的表达式就不再计算。

③.! 运算符

!运算符:对原条件取反。真 ==>假 \ 假 ==>真

7.条件运算符

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);
    }
}

①.运算符优先级

图片[14]-Java基础篇-HuaのJava之旅

三、选择结构

1.多重if结构

图片[15]-Java基础篇-HuaのJava之旅
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("不及格!");
        }
    }
}

2.嵌套if结构

图片[16]-Java基础篇-HuaのJava之旅
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);
                }
            }
        }
    }
}

3.switch结构

if结构:判断条件是布尔类型。判断条件是一个范围。

switch结构:判断条件是常量值。

图片[17]-Java基础篇-HuaのJava之旅
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的范围!");
        }
    }
}

四、循环结构

1.while循环

图片[18]-Java基础篇-HuaのJava之旅
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);
    }
}

2.do…while循环

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);
    }
}

3.For循环

图片[19]-Java基础篇-HuaのJava之旅

For执行顺序:首先会运行表达式1:int n=1,在循环中只运行一次

图片[20]-Java基础篇-HuaのJava之旅
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的一种新用法!用来循环遍历数组和集合。

增强型For循环又叫ForEach循环。

for(int e:a){
    System.out.println(e)
}

②.增强型for循环与普通for循环的区别

  1. 增强for循环书写简洁,遍历数组时不需要下标,主要用于数组或集合的遍历,数组或集合遍历完成时循环结束执行。
  2. 增强for循环需要三个条件:
    1. 包括循环变量
    2. 循环结束条件
    3. 循环变量的变化,
  3. 在进行数组遍历时,如果需要使用下表,可以使用普通for循环。比如:从键盘接收数组元素时,提示输入第几个元素。如果使用增强型for循环需要额外定义变量。

4.break和continue

①.break

用break语句可以使流程跳出switch语句体,也可以用break语句在循环结构终止本层循环体,从而提前结束本层循环。

使用说明:

(1)只能在循环体内和switch语句体内使用break;

(2)当break出现在循环体中的switch语句体内时,起作用只是跳出该switch语句体,并不能终止循环体的执行。若想强行终止循环体的执行,可以在循环体中,但并不在switch语句中设置break语句,满足某种条件则跳出本层循环体。

②.continue

continue语句的作用是跳过本次循环体中余下尚未执行的语句,立即进行下一次的循环条件判定,可以理解为仅结束本次循环。

注意:continue语句并没有使整个循环终止。

五、一维数组

数组是相同类型的数据按顺序组成的一种引用数据类型。

1.语法格式

数据类型[] 数组名;  //int[] myIntArray;

数据类型 数组名[];  //int myIntArray[];

2.数组创建

语法格式一:先声明后创建。

数据类型[] 数组名;  //int[] arr;

数组名 = new 数据类型[数组长度];  //arr = new int[10];

/*创建一个长度为10的数组。*/

语法格式二:声明的同时创建数组。

数据类型[] 数据名 = new 数据类型[数组长度];  //int[] arr = new int[10];

/*创建长度为10的整型数组arr*/

注意:数组长度必须指定。数组在内存中存储

图片[21]-Java基础篇-HuaのJava之旅

①.数组初始化

声明的同时给变量赋值,叫做数组初始化。

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开始。

图片[22]-Java基础篇-HuaのJava之旅

②.数组长度

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];

图片[23]-Java基础篇-HuaのJava之旅

1.给二维数组赋值

//为第2行第3个元素赋值为9
intArray[2][3]=9;
//声明数组的同时并创建
char[][] ch=new char[3][5];
//创建float类型的数组时,只指定行数不指定列数
float[][] fl=new float[3][];  //列数可以省略,行数绝对不能省略。

2.可以定义每行有几列

//每行相当于一个一维数组

floatArray[0]=new float[3];  //一行有3列
floatArray[0]=new float[4];  //一行有4列
floatArray[0]=new float[5];  //一行有5列

3.二维数组初始化

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方法是语句的集合,它们在一起执行一个功能。

  • 方法是解决一类问题的步骤的有序组合;
  • 方法包含于类或对象中
  • 方法在程序中被创建,在其他地方被引用

1.方法命名规范

  • 1.始终遵循驼峰命名法
  • 2.方法的名字的第一个单词应以小写字母作为开头,后面的单词则用大写字母开头写,不使用连接符。例如:addPerson
  • 3.下划线可能出现在 JUnit 测试方法名称中用以分隔名称的逻辑组件。例如 testPop_emptyStack

2.方法的定义

修饰符 返回值类型 方法名(参数类型 参数名){
    ...
    方法体
    ...
    return 返回值;
}

方法包含一个方法头和一个方法体。下面是一个方法的所有部分:

  • 修饰符:修饰符,这是可选的,告诉编译器如何调用该方法。定义了该方法的访问类型。
  • 返回值类型 :方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作,但没有返回值。在这种情况下,returnValueType 是关键字void
  • 方法名:是方法的实际名称。方法名和参数表共同构成方法签名。
  • 参数类型:参数像是一个占位符。当方法被调用时,传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的,方法可以不包含任何参数。
  • 方法体:方法体包含具体的语句,定义该方法的功能。
图片[24]-Java基础篇-HuaのJava之旅

3.方法分类

根据方法是否带参数、是否返回值,可分为四类:

  1. 无参无返回值方法
  2. 无参带返回值方法
  3. 带参无返回值方法
  4. 带参带返回值方法

①.无参无返回值方法

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));//调用并输出
    }
}

4.数组作为方法参数

例:定义方法,打印输出数组元素的值。

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);
    }
}

5.方法重载

方法名相同,参数列表不同。这里的参数列表不同指的是,参数的数量不同,或者参数的数据类型不同。

public void display(){}

public void display(int n){}

public void display(float n){}

如下两个方法不是重载方法,两个方法只是参数名不同,不满足方法重载条件。

public void display(int n){}

public void display(int d){}

6.方法传值

传递两个参数调用方法。有趣的是,方法被调用后,主方法内的值并没有改变。

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();
    }
}

7.可变参数列表

在方法声明中,在指定参数类型后加一个省略号(…)

参数列一个方法中只能指定一个可变参数,它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

可以将数组传递给可变参数,不能将可变参数列表传递给数组。

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));
    }
}
© 版权声明
THE END
喜欢就支持一下吧
点赞0 分享
评论 共1条
头像
欢迎您留下宝贵的见解!
提交
头像

昵称

取消
昵称表情代码图片
    • Sunny的头像-HuaのJava之旅SunnyLV3作者0