Java知识点总结

第三章 流程控制语句&方法定义

3.1语句

语句又分为单语句和复合语句.

3.1.1单语句

(1)空语句,什么都没有,只包含一个";"

(2)表达式语句

new表达式;

方法调用表达式;

计算中的赋值表达式和自增自建表达式;

3.1.2 复合语句

(1) 分支语句:if...else...;switch....case...

(2)循环语句:for,while,do..while..

(3)跳转语句:break,continue,return

3.2输出输入语句

3.2.1 输出:

常见的两种输出语句

(1)输出不换行:System.out.printl();

(2)输出换行:System.out.println();

3.2.2 输入:

进行键盘导包输入,代码示例:

import java.util.Scanner;//导入java中的包
class explore{
    public static void main(String[] args){
        Scanner hb=new Scanner(System.in);//创建新的数据对象
        int a=hb.nextInt();//来接收int类型的数据
    }
}

有关int和String的区别:

int类型的就对应由nextInt()来接收;String的对应由nextLine()来接收;

3.3顺序结构

即从上而下依次运行,表达式语句都是顺序结构来保证程序正常的运行.

3.4选择结构

3.4.1单分支条件判断

即一个if的条件判断:(代码示例)

if(条件判断){
    执行语句;
}

3.4.2双分支条件判断

即if...else...语句:

if(条件判断)
    执行语句;
else
    执行语句;
//这里注意适用于只有两种情况的条件判断,非第一种即第二种;

3.4.3 多分支条件判断

即if...else if...else...语句

if(条件判断1){
    执行语句1;
}else if(条件判断2){
    执行语句2;
}.....{
}else
    执行语句;
//适用于多种情况的条件判断,分情况写出

3.4.4 if...else嵌套

指的是在一个if或者else条件判断中又包含另一个if判断

执行特点:

(1)如果是在嵌套里的if条件判断的话,只有当上层的if条件满足时才会进入嵌套里的if判断;

(2)如果是在嵌套里的else条件时,只有当if不满足时才会进入else中进行判断;

3.4.5switch....case...多分支选择结构

代码示例:

switch( 表达式){
    case 情况1:
        执行语句1;
        [break;]
    case 情况2:
        执行语句2;
        [break;]
    .....
    default:
        执行语句n;
        [break;]
}
//本循环适用于有多个具体的选择的循环,当存在多个选择结果相同时可以把case 写在一起;
//case 穿偷性:
当缺少break时,进入循环后会一直执行下去,知道遇见break 或者{;

3.5 循环结构(重要)

3.5.1循环结构的分类

for循环

while循环

do....while..循环

3.5.2循环结构for语句的格式和基本使用

for循环格式:

    for(初始化语句;循环条件语句;循环控制条件语句){
        执行语句;
    }
//注意在for循环括号里的两个; 不能少

经典例题,求100-1000里的水仙花数有多少个:

class excise{
    public static void main(String[] args){
        int count=0;//计数器思想
        for(int i=100;i<1000;i++){
            int a=i%10;//表示个位
            int b=i%100/10;//表示十位
            int c=i/100;//表示百位
            if (a*a*a+b*b*b+c*c*c)==i;
                count++;
        }
        System.out.println(count);
    }
}

3.5.3循环结构while语句的格式和基本使用

while 循环格式:

初始化语句;
while(条件判断语句){
    执行语句;
    流程控制语句;
}

经典例题:输出100-1000的水仙花数:

class excise{
    public static void main(String[] args){
        int count=0;//计数器思想
        int i=100;
        while(i<1000){
            int a=i%10;//表示个位
            int b=i%100/10;//表示十位
            int c=i/100;//表示百位
            if (a*a*a+b*b*b+c*c*c)==i;
                count++;
            i++;
        }
        System.out.println(count);
    }
}

for循环和while循环的区别:

for循环适用于知道具体范围的情况;while循环更适用对循环范围不了解的情况.

3.5.4循环结构do..while语句的格式和基本使用

do...while格式

初始化语句;
do{
    循环体语句;
    流程控制语句;
}while(循环条件语句);

案例分析:(输出1-10的数字)

public static void main(String[] args) {
        int i = 1;
        do {
            System.out.println(i);
            i++;
        } while (i<=10);
}

3.5.5循环嵌套(重点)

定义:是指在一个循环的循环体是另一个循环,即循环里面包含循环;

for循环嵌套格式:

for(初始化语句1;循环条件语句1;控制语句1){
    for(初始化语句2;循环条件语句2;控制语句2){
        执行语句;
    }
}

执行特点:

外循环控制行数,内循环控制列数;

即外循环执行一次,内循环执行一轮.

案例分析:(打印出99乘法表):

class excise{
    public static void main(String[] args){
        int j;
        for(int i=1;i<10;i++){
            for(j=1;j<=i;j++){
                System.out.print(j+"*"+i+"="+(i*j)+" ");
            }
        System.out.println();
        }
    }
}

3.5.6 控制跳转语句

分别有 break;continue;return

break:

指的是退出,结束;常常用在循环内;

continue:

指的是退出本次循环,立即进入下次循环;只用于循环内;

return:

指的是返回值;用于方法的结束时对结果的定义;

3.6方法的定义和使用(重难点)

3.6.1方法的作用以及什么是方法

方法是完成特定功能的代码块;其作用是为了提高代码的复用性.

3.6.2方法的格式以及格式说明

格式:

修饰符 返回值类型 方法名(数据类型 数据名1,数据类型 数据名2){
    方法体语句;
    return 返回值;
}
方法声明的位置:必须在类中方法外,另外不能在一个方法内直接声明另一个方法.

3.6.3 方法的定义和调用

3.6.3.1方法定义需要明确的内容

明确返回值类型

明确参数列表

3.6.3.2案例

键盘录入两个值,比较其中更大的一个:

import java.util.Scanner;
class excise{
    public static void main(String[] args){
        Scanner hb=new Scanner(System.in);
        int a=hb.nextInt();
        int b=hb.nextInt();
        System.out.println(getmax(int a,int b));
    }
    public static int getmax(int a,int b){
        int max=a>b?a:b;
        return max;    
    }
}

3.6.3.3 方法重载概述和基本使用

方法概述:

在同一个类中,方法名相同,参数类型,参数个数,参数的顺序不同,与返回值类型无关.

重载方法调用：JVM通过方法的参数列表，调用匹配的方法。

* 先找个数、类型最匹配的

* 再找个数和类型可以兼容的，如果同时多个方法可以兼容将会报错

3.6.4方法的递归

方法自己调用自己的现象即称为递归.

第四章 数组

4.1数组的概念以及作用

数组的概念:就是把相同数据类型的数据放在一起的一个集合,然后在按顺序统一管理,按从0开始计数,称为每个元素的索引值(Index),整个数组所有元素的个数称为其长度(length);

作用:便于统一的管理数据以及更有条理,数据一旦定义,其长度就不能再更改.

4.2 一维数组的声明与使用

4.2.1 数组的定义格式

数据类型[] 数组名=new 数据类型[数组的长度];

4.2.2 一维数组的初始化

初始化即是为数组在内存中开辟空间,在Java中必须要先初始化.

静态初始化: 数据类型[] 数组名=new 数据类型[]{参数1,参数2.....};

动态初始化:数据类型[] 数组名 =new 数据类型[数组长度];

4.2.3 一维数组的常见运用

一般的,我们会把数组和循环组合起来使用,用来解决一些问题,我这里就只举一个冒泡排序的例子(用来给数组进行排序):

class excise{
    public static void main(String[] args){
        int[] gym=new  int[]{23,32,12,43,54,13};//初始随便定义一个无序数组
    //我们这里使用方法的概念,定义一个排序数组的方法sourtarray
        sourtarray(gym);
        print(gym);
    }
    public static void sourtarray(int[] arr){
        for(int i=0,i<arr.length-1;i++){
            for(int j=0,j<arr.length-i-1;j++){
                if arr[j]>arr[j+1]
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
            }
        }
    }
//再写一个打印并且遍历数组的方法
    public static void print(int[] arr){
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}

4.3 二维数组

后面讲了再写

第五章 面向对象

5.1 面向对象编程

5.1.1面向对象编程思想概述

Java是一种面向对象的编程语言,其是以类作为单位,每种事物也有自己的属性,面向对象语言所具有的特点:1.这是一种更符合人类逻辑思维的语言;2.能把复杂的事物简单化;3.使我们的角色由执行者转化为指挥者;面向对象的编程思想也称为OOP(Object-Oritened-Progranmming)

C语言是一种面向过程的编程语言,其是以函数作为单位,这样也减少了代码的冗余性,便于维护,其面向过程的编程思想也称为POP,(Process-oritened_Programming)

5.1.2类和对象

5.1.2.1 什么是类和对象

类是具有相同属性的一类事物的抽象描述,是一组相关事物属性和行为的集合.

类中包括 成员变量,成员方法,构造方法.

对象是一类事物中的某个具体的个体;

5.1.2.2 怎么去定义

定义类 :

claas 类名{

成员变量

成员方法

构造器

构造器

成员内部类

}

定义对象:

这里我来定义一个 class phone并测试

class phone{
    private String name;
    private int price;
    private String color;
    public phone(){};
    public phone(String name,int price,String color){
        this.name=name;
        this.price=price;
        this.color=color;
    }
    public void setName(String name){
        this.name=name;
    }
    public void setPrice(int price){
        this.price=price;
    }
    public void setColor(String color){
        this.color=color;
    }
    
    public String getName(){
        return name;
    }
    public int getPrice(){
        return price;
    }
    public String getColor(){
        return color;
    }
    public static void playgame(String name){
        System.out.println("同学们都喜欢用手机打"+name);
    }
}
class phoneTestpuls{
    public static void main(String[] args){
        phone one=new phone("iphone14pro max",9999,"远峰蓝");
        System.out.println("手机的名称是:"+one.getName()+",价格为:"+one.getPrice()+
            ",颜色是"+one.getColor());
        one.playgame("和平金鹰");
    }
}

private关键字的特点:

(1)被private修饰的成员变量或者成员方法(非静态的)只能在本类中访问,外界类不能访问!

(2)虽然被私有修饰的成员变量以及成员方法不能被直接访问,但是我们可以间接的通过"public"公共访问!

面试题:

成员变量和局部变量有什么区别:

1. 所处位置不同

成员变量一般处于类中并且方法外;局部变量一般处于方法声明中或者方法定义内;

1. 内存中的位置不同

new出来的成员变量处于堆内存中;局部变量处于栈内存中;

1. 生命周期不同

成员变量随着对象的创建而存在,随着对象的创建完毕以及使用完毕即等待垃圾回收站来回收(不是立即消失的)

局部变量随着方法的调用而存在,结束即消失;(这里局部变量也分基本数据类型和引用数据类型)

1. 初始值不同

成员变量当没有初始值的时候,系统会默认有初始值,当然自己也可以进行初始化;

局部变量必须赋予初始值在使用之前.