Java的基本语法

Java 的基本语法格式

[修饰符] class 类名{
	程序代码
}

编写Java程序时，应注意的几点：

  1. Java 中的程序可分为结构定义语句和功能执行语句。

结构定义语句用于声明一个类或者方法。
功能执行语句用于实现具体的功能。（每条功能执行语句的结尾必须使用英文 “ ; ”结束）
功能执行语句示例：

System.out.println("Hello World");
  1. Java 语言区分大小写。
  2. 在编写Java代码时，方便阅读，通常使用一种良好的格式排版。
public class Helloworld{
    public static void main(String[] args){
        System.out.println("Hello World");
    }
}
  1. Java 程序中一个连续的字符串不能直接分在两行中书写。

注释

单行注释

int c = 10  // 定义一个整型变量c

多行注释

/* 定义一个整型变量x
将5赋值给变量*/
int x;
x = 5；

文档注释

/**
*Title: HelloWorld类
*@author srx
*@version 1.0
*/
public class Helloworld{
	/**
	*这是一个main()方法入口
	*@param args 参数名
	*/
    public static void main(String[] args){
        System.out.println("Hello World");
    }
}

关键字：java本来就有的内容

【1】全是小写的纯英文字母
【2】有特殊颜色

Java标识符

组成：标识符可以由任意顺序大小写字母、数字、下划线、和美元符号组成，但不能由数字开头、也不能使用Java中的关键字。
规则：
【1】可以包含 英文字母26个(大小写), 0-9数字, $ 和 _
【2】不能数字开头
【3】不能是关键字

Java中的变量与常量

常量：固定不变的量

分类：

字符串常量(string):双引号之中一定是
整数常量(int):直接写的数字，没小数点
浮点数常量(float):直接写的数字，有小数点
字符常量(character):单引号之中的单个字符一定是
布尔常量(boolean):true / false
空常量(null):null 没有任何数据

变量:可以改变的量

创建格式：数据类型 变量名； 数据类型 变量名 = 数据值；
基本使用:
【1】打印变量名称，显示内容
【2】long num = 30000000000L; float num = 2.5F;
【3】赋值1：变量名 = 数据值；
【4】赋值2：变量名 = 变量名；
TIPS：
【1】变量名直接不能重复
【2】定义变量后，一定要进行赋值
【3】变量使用不能超过作用域的范围
作用域：从定义变量开始到大括号为止
【4】同时创建相同数据类型变量：

数据类型 变量名1，变量名2，变量名3；
数据类型 变量名1 = 数据值1，变量名2 = 数据值2，变量名3 = 数据值3；

变量的数据类型

  • 整数型：byte(1) int(4)(默认) short(2) long(8)
  • 浮点型：float(4) double(8)(默认)
  • 字符型：char(2)
  • 布尔型：boolean(1)

变量的类型转换

(1).自动类型转换（隐式）
A.代码不需要特殊处理，自动完成
B. 数据范围从小到大

long num = 100;
double num = 2.5;
float num = 30; //30.0

(2).强制类型转换（显式）
A.代码需要进行特殊格式处理，不能自动完成
B.范围小的类型 范围小的变量名 = （范围小的类型）原本范围大的数据;

int num = int(100);

Java中的运算符

算术运算符

算术运算符： 四则运算，取余数%，自增++，自减- -
TIPS：
如果运算中有不同数据类型，结果将会是范围大的那种

赋值运算符

赋值运算符：
【1】基本赋值运算符：=
【2】符合赋值运算符：+=，-=，*=，/=，%=
a+=1 等于 a = a + 1

逻辑运算符

逻辑运算符：与(&&) 或(||) 非 (!)
与，或，具有短路效果：如果根据左边可以得到正确的结果，右边将不执行

TIPS：
【1】比较运算符只用于boolean
【2】与，或需要两个boolean，非只需要一个boolean
【3】与，或可以连接多个条件

比较运算符

比较运算符：==，<，>，<=，>=，!=
TIPS：
【1】返回结果一定是一个boolean值
【2】如果多次判断，不能连着写 不允许：1<x<2

选择结构语句

if 语句

//格式1
if (关系表达式) {
  语句体；
}

//格式2
if (关系表达式) {
   语句体1；
}else {
   语句体2；
}

//格式3
if (判断条件1) {
  语句体1；
}else if (判断条件2) {
  语句体2；
}else if (...) {
  ...
}else {
  语句体n；
}

Switch 条件语句

//格式
switch(表达式) {
  case 常量值1:
  语句体1;
  break;
  case 常量值2:
  语句体2;
  break;
  ...
  default:
  语句体n;
  break; //可省略
}

循环结构语句

循环结构的基本组成部分
A.初始化语句：最开始时执行，只执行一次
B.条件判断：成立则继续，否则退出
C.循环体：重复要做的事
D.步进语句：每次循环最后都要进行

While循环语句

//标准格式
while (条件判断) {
  循环体；
}

//拓展格式
初始化语句；
while (条件判断) {
  循环体；
  步进语句；
}

do…while循环语句

//标准格式
do {
  循环体；
} while （条件判断）

//拓展格式
初始化语句
do {
  循环体；
  步进表达式
} while （条件判断）

for循环语句

for (初始化语句；布尔表达式；步进表达式) {
   循环体；
}

循环嵌套

循环中放循环

跳转语句（break、continue）

循环控制：条件控制语句
A.break
可以在switch中使用,switch语句结束
可以在循环语句中使用，循环语句结束
B.continue
立刻跳过当前次循环剩余内容，马上开始下一次循环

数组

概念: 一种容器，可以同时存放多个数据值

特点
【1】是一种引用数据类型
【2】数组中的多个数据类型必须统一
【3】数组的长度在运行期间永不改变

数组的初始化
在内存中创建，并向其中赋予一些默认值
(1).动态初始化（指定长度）

//标准格式
数据类型[] 数组名称 = new 数据类型[数组长度];
//可拆分成两个步骤
数据类型[] 数组名称；
数组名称 = new 数据类型[数组长度];

(2).静态初始化（指定内容）

//标准格式
数据类型[] 数组名称 = new 数据类型[]{元素1,元素2,…};
//可拆分成两个步骤
数据类型[] 数组名称；
数组名称 = new 数据类型[]{元素1,元素2,…};

//省略格式
数据类型[] 数组名称 = {元素1,元素2,…};

数组的常见操作

取数组的最大值

/*定义一个获取最大值的功能:
        1、确定结果 ：返回值类型 int
        2、未知内容：要获取哪个数组的最大值没有确定，则是数组没有确定

    思路：
        1、定义一个变量，记录住数组的比较大的元素。
        2、遍历整个数组，让数组的每一个元素都和该变量进行对比即可。
        3、当变量遇到比它大的元素，则让该变量记录该元素的值，当循环结束时，最大            值产生了
    */

    public static int getMax(int[] arr)
    {
        //定义变量记录较大的值，初始化为数组中的任意一个元素。
        int max = arr[0];

        for(int x=1; x<arr.length; x++)
        {
            if(arr[x]>max)
                max = arr[x];
        }
        return max;

    }

直接排序

/*
    选择排序。
    以一个角标的元素和其他元素进行比较。
    在内循环第一次结束，最值出现的头角标位置上。
    */
    public static void main(String[] args) 
    {
        int[] arr = {12,5,17,8,9};  //对于5元素的数组，只需要找出4个最大值就可以排序了。
        selectSort(arr);
    }

    public static void selectSort(int[] arr){

        //把最大值放在首位置。
        for(int j = 0; j<arr.length-1; j++){  //  控制的是轮数。
            for(int i = j+1 ; i<arr.length ; i++){ // 找出最大值
                if(arr[i]>arr[j]){
                    //交换位置
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }


        //遍历数组，查看效果
        System.out.print("目前的元素：");
        for (int i = 0 ; i<arr.length  ;i++){
            System.out.print(arr[i]+",");
        }

    }

冒泡排序

/*
    冒泡排序。
    比较方式：相邻两个元素进行比较。如果满足条件就进行位置置换。
    原理：内循环结束一次，最值出现在尾角标位置。
    */
    public static void main(String[] args) 
    {
        int[] arr = {12,8,17,5,9}; // 最大的索引值: 4   容量：5 
        bubbleSort(arr);
    }


    public static void bubbleSort(int[] arr){
        // 把最大值放在最后一个位置
        for(int j = 0 ; j<arr.length-1 ; j++){ //控制轮数
            for(int i = 0 ; i<arr.length-1-j  ; i++){  // 找出一个最大值   -1:避免角标越界。 -j:让每次参与比较的元减
                if(arr[i]>arr[i+1]){//相邻的元素比较
                    int temp  = arr[i];
                    arr[i] = arr[i+1];
                    arr[i+1] = temp;
                }
            }
        }


        //遍历数组，查看效果
        System.out.print("目前的元素：");
        for (int i = 0 ; i<arr.length  ;i++){
            System.out.print(arr[i]+",");
        }

    }

多维数组

Java 语言中提供支持多维数组的语法
对于二位数组可以理解为数组中的数组

初始化方式

public class test {
    public static void main(String[] args){
        //静态初始化
        int[][] arr = new int[][]{{1, 2, 3}, {4, 5}, {7, 8}};
        //动态初始化1
        int[][] arr1 = new int[3][2];
        //动态初始化2
        int[][] arr2 =new int[3][];//不指明列数
    }
}

二维数组的使用
规定：二维数组分为外层数组的元素，内层数组的元素int[][]arr=new int[2][3]；外层元素：arr[e]，arr[1]等内层元素：arr[e][e]，arr[1][2]等

数组元素的默认初始化值
针对于初始化方式一：比如：int[][]arr=new int[4][3]；
外层元素的初始化值为：地址值
内层元素的初始化值为：与一维数组初始化情况相同针
对于初始化方式二：比如：int[][]arr=new int[4][]；
外层元素的初始化值为：nu11
内层元素的初始化值为：不能调用，否则报错。

方法

方法完整定义格式

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

修饰符: public static 目前固定
参数：进入方法的数据
返回值：从方法中出来的数据

方法的三种调用格式：

  1. 单独调用：方法名称(参数);
  2. 打印调用：System.out.println(方法名称(参数));
  3. 复制调用：数据类型 变量名称 = 方法名称(参数);

有参数方法和无参数方法
小括号中有没有内容

有返回值方法和无返回值方法
void为无返回值方法

方法重载（overload）
多个方法有相同的名称，但参数列表不同
同一个方法名可以实现类似的多个功能

TIPS：
方法重载与下列因素有关:

  1. 参数个数不同
  2. 参数类型不同
  3. 参数的多类型顺序不同

方法重载与下列因素无关:

  1. 与参数名称无关
  2. 与方法的返回值类型无关

面向对象

概述

面向过程：当实现一个功能时，每一个具体的步骤都要亲力亲为，处理每个细节
面向对象：当实现一个功能时，不关心具体步骤而是找具有该功能的人，帮忙处理

类和对象

类：一组相关属性和行为的集合，可看作是一类事物的模版
属性：该事物的状态信息
行为：该事物能够做什么
对象：一类事物的具体体现，对象是类的一个实例

类是抽象的对一类事物的描述
对象是体力的是一类事物的实例
类是对象的模版，对象是类的实体

类的定义

格式

public static ClassName {
  //成员变量
  //成员方法
}

成员变量：对应事物的属性
成员方法：对应事物的行为（去掉static）

对象的创建和使用

导包：指出需要使用的类在什么位置

import 包名称.类名称

对于和当前类属于同一个包的情况，可以省略导包语句
创建

//格式
类名称 对象名 = new 类名称();

使用
A.使用成员变量：对象名.成员对象名
B.使用成员方法：对象名.成员方法名(参数)

TIPS：
如果成员变量没有赋值，将会有一个默认值，规则和数组一样

面向对象的三大特征之封装

封装：把一些细节信息隐藏起来，对外界不可见
A.方法就是一种封装
B.关键字private也是一种封
继承
多态

private关键字的作用以及使用

  • 无法阻止不合理的数据被设置进来，用private来解决
  • 使用private后，本类中依然可以随意访问，但超出本类范围之外就不能直接访问了
  • 间接访问private变量，定义一对getter，setter方法

setter/getter命名规则：
getter：不能有参数，返回值类型和成员变量对应
setter：不能有返回值，参数类型和成员变量对应

_this关键字的作用

  • 当局部变量和类的成员变量重名时，根据“就近原则”，优先使用局部变量
  • 如果需要访问本类当中的成员变量，需要使用格式：
    this.成员变量名
  • 通过谁调用的方法，谁就是this

构造方法

构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象时，其实是在调用构造方法
格式：

public 类名称(参数类型 参数名称) {
  方法体
}

TIPS：

  • 构造方法的名称必须和类名称完全一样，就连大小写也要一样
  • 构造方法不要写返回值类型，连void都不写
  • 构造方法不能return一个具体的返回值
  • 如果没有任何构造方法，那么编译器会默认赠送一个构造方法，没有参数，方法体什么都不做
  • 一旦编写了至少一个构造方法，那么编译器将不再赠送
  • 构造方法也是可以进行重载的
  • 重载：方法名称相同，参数列表不同
//全参构造方法
public Student(String name, int age){
  this.name = name;
  this.age = age;
}

Student stu = new Student(name:a, age:b);

标准的类

  • 所有成员变量都要使用private修饰
  • 为每一个成员变量编写一对getter/setter
  • 编写一个无参数的构造方法
  • 编写一个全参数的构造方法
    这样的类也叫做java bean

快速创建方法：

  • code->generate->getter and setter
  • code->generate->constructor->select all
    快捷键：control+enter