Java的基本语法
Java 的基本语法格式
[修饰符] class 类名{
程序代码
}
编写Java程序时,应注意的几点:
- Java 中的程序可分为结构定义语句和功能执行语句。
结构定义语句用于声明一个类或者方法。
功能执行语句用于实现具体的功能。(每条功能执行语句的结尾必须使用英文 “ ; ”结束)
功能执行语句示例:
System.out.println("Hello World");
- Java 语言区分大小写。
- 在编写Java代码时,方便阅读,通常使用一种良好的格式排版。
public class Helloworld{
public static void main(String[] args){
System.out.println("Hello World");
}
}
- 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 目前固定
参数:进入方法的数据
返回值:从方法中出来的数据
方法的三种调用格式:
- 单独调用:方法名称(参数);
- 打印调用:System.out.println(方法名称(参数));
- 复制调用:数据类型 变量名称 = 方法名称(参数);
有参数方法和无参数方法
小括号中有没有内容
有返回值方法和无返回值方法
void为无返回值方法
方法重载(overload)
多个方法有相同的名称,但参数列表不同
同一个方法名可以实现类似的多个功能
TIPS:
方法重载与下列因素有关:
- 参数个数不同
- 参数类型不同
- 参数的多类型顺序不同
方法重载与下列因素无关:
- 与参数名称无关
- 与方法的返回值类型无关
面向对象
概述
面向过程:当实现一个功能时,每一个具体的步骤都要亲力亲为,处理每个细节
面向对象:当实现一个功能时,不关心具体步骤而是找具有该功能的人,帮忙处理
类和对象
类:一组相关属性和行为的集合,可看作是一类事物的模版
属性:该事物的状态信息
行为:该事物能够做什么
对象:一类事物的具体体现,对象是类的一个实例
类是抽象的对一类事物的描述
对象是体力的是一类事物的实例
类是对象的模版,对象是类的实体
类的定义
格式
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