小白入门级别。Java基础知识
Java的基本语法
1.Java代码的基本格式
-
Java语言是严格区分大小的。
-
Java程序代码可分为结构定义语句和功能执行语句，结构定义语句是声明一个类或方法。功能执行语句是实现具体功能。
-
在语句结束后面要加英文半角格式下的（；），英文格式下的。
-
如果一句语要分为两行，要换行记得要添加（+）
System.out.println("这是我第一次创建
+Hellow word");
2.Java中斜体样式的注释
- 单行注释
int i=3;//将3的赋值给i
- 多行注释
/*
class student{
private String Name;
private int age;
}
.......
*/
-
文档注释
以/**开头，*/结尾的 -
在命名时要记得，项目名，和包名可以小写，而类要大写。切忌不要以关键字命名。包类其实也可以用中文命名。
判断容易出错的关键字有 goto,do,new,class,abstract,package…
这些不用死记硬背，日后熟悉了便一目了然的
3.Java中的常量
- 常量包括整型常量，浮点数常量，布尔常量，字符常量。但是请记住常量是程序中固定不变的值，是不可改变的数据。
整型常量
| 二进制 | 由数字0和1组成 |
|---|---|
| 八进制 | 以0头并且其后由0-7组成 |
| 十进制 | 由数字0~9范围内的整数组成的数字 |
| 十六进制 | 以0x或0X开头开头并且其后由0-9，A-F组成 |
浮点常数
分为float单精度浮点数（后面以F或f结尾）和double双精度浮点数（后面以D或d结尾）。
字符常量
由英文半角格式的单引号 ’ '引起来
字符串常量
由 英文半角格式的双引号“ ”引起来
布尔常量
一般分为true和false；
null常量
只有一个null，表示对象的引用为空
4.Java的变量
- 变量的定义
通俗点讲变量就是一个容器，存放东西。容器也就是变量，东西也就是变量名。也就是赋值。
int a=3;
double d2=22.23;
官方讲法是这样子的：将数据保存在一个内存单元中，每个内存单元用一个标识符来辨别。而这些内存单元就成为变量，而定义的标识符为变量名。
- 变量的数据类型
- 整数类型变量
| 类型名 | 占用空间 |
|---|---|
| byte | 8位（1个字节） |
| short | 16位（2个字节） |
| int | 32位（4个字节） |
| long | 64位（8个字节） |
注意long类型变量赋值后面要加l或L；
long i=20000000000L；
- 浮点数类型常量
float a=123.4f；//float赋值的数后面必须加F或f
double b=123.1；//而double可加或不加（D或d）
| 类型名 | 占用空间 |
|---|---|
| float | 32位（4个字节） |
| double | 64位（8个字节） |
- 字符型变量
用char表示，每个char类型的字符变量会占用2个字节空间，而在用char赋值的时候用英文半角格式的单引号’ '给括起来。
char b ='a';
char biu='101';
- 布尔类型变量
要用boolean表示
boolean j=true;//初始值为true
j=flase;//改变j的变量为flase
变量的类型转换
1.自动类型转换
自动类型转换也叫隐式类型转换。
实现自动类型需要满足两个条件：
- 目标类型的取值大于源类型的取值范围。
- 两种类型彼此兼容。
以下是可以自动类型转换的类型
- 整数类型之间可以相互转换。byte可以赋值给short，int，long。
short，char可以赋值给int，long。
int可以赋值给long。
int i=3;//int自动转换为long
long by=i;
byte b=22;//byte自动转换为int
int bf=b;
char c='7';//char自动转换为int
int v=c;
- 整数类型可以转换为float类型，如byte，char，short，int都可以赋值给float。
float b=9f;//float 自动赋值给int
int i=(int) b;
float t=2.3f;//float自动赋值给char
char u=(char)t;
- 其他类型可以转换为double类型。如byte，short，char，long，float，int。
double yu=3；//double自动赋值给int
int t=（int）yu；
注意，float和double赋值给别的类型，记得那个被赋值的式子后面要加赋值的类型。不然打代码的时候是会出现错误的。
算术运算符
我们先举例几个比较特殊
| 运算符 | 运算 |
|---|---|
| 乘 | * |
| 除 | / |
| 取模 | % |
| ++ | 自增 |
| - - | 自减 |
关于自增有分自增前，和自增后。自减也是一样。
下面举例说明
自增前
a=3,b=++a;
a=4,b=4;
自增后
a=3;b=a++;
a=4,b=3;
自减前
a=2,b=--a;
a=1;b=1;
自减后
a=2,b=a--;
a=1;b=2;
现在通过eclipse案例，加强一下知识点。
赋值运算符
只举例特殊的。,在Java语言中，“ = ”不是叫等号，而是赋值
- 一条赋值语句是可以给许多变量进行赋值
int a,b,c,d;//同时为4个量赋值
a=b,c,d=77;
下面演示以下错误的写法
int a=b=c=d=77;
- 还有+=，-=，*=，/=，%=这些要注意。例如x+=3相当于x=x+3;其他依次类推。
逻辑运算符
逻辑运算符用于对布尔型的数据进行操作，其结构也是一个布尔型数据。
- 逻辑运算符可以针对结果为布尔值的表达式进行运算
- 运算符&和&&表示与操作。&&称为短路与。
2.强制类型转换
强制类型转换也叫显示转换。如果它们不满足自动类型转换的两个条件，那么它就需要进行强制类型转换。
选择结构语句
if条件语句
- if结构语句
是指满足某种条件，就进行某种处理。
下面我们就通过一个简单的案例进行理解。
int a=100;//如果a的值大于0，就进行自减
if(a>0){
a--;
System.out.println("a的值为"+a)；
}
}
- if… else语句
如果满足某种条件，就进行某种处理，否则就进行另外一种处理。
下面我们就通过一个简单的案例进行理解
int a =44；//如果a能被整除，则输入语句。否则，反之。
if(a%2==0){
System.out.println("a能被整除");
}else{
System.out.println("a不能被整除");
}
- if…else if …else语句
进行多条件进行判断
下面我们通过一个简单的案例进行理解
packeage 测试类
public class Example{
public static void main(String[] args){
//通过一个顾客的积分，判断该顾客在本店消费金额达到哪个vip
int a=5210;//该顾客在本店消费换得的积分为1000000；
if（a<=1500）{
System.out.println("该顾客为倔强青铜");//不满足条件往下，依次类推。
}else if (a>=2500){
System.out.println("该顾客为秩序白银");
}else if (a>=5000){
System.out.println("该顾客为荣耀黄金");
}else if（a>=5200）{
System.out.println("该顾客为尊贵铂金");
}else if（a>=6000){
System.out.println("该顾客为永恒钻石");
}else if（a>=8000）{
System.out.println("该顾客为至尊星耀");
}else (a=100000){
System.out.println("该顾客为最强王者");
}
}
- switch 条件语句
它是选择语句。只能针对某个表达式做出判断。从而执行哪个一段代码。
public class Example{
public static void main(String[] args){
int week=7;//判断是星期几，并执行哪个代码
switch(week){
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:
Syetem.out.println("输入的数字不正确");
}
}
}
循环语句
- while循环语句
只要条件成立，（）内的执行语句会一直循环下去。
public class Example{
public static void main(String[] args){
int a=1;//如果a<=7则进行自减并依次循环。如果>7则循环结束
while(a<=7){
System.out.println("a="+a);
a++;
}
}
}
- do…while语句
while循环语句功能和do…while循环语句功能一样。
public class Example{
public static void main(String[] args){
int a=1;
do{
System.out.println("a="+a);
x++;
}whlie(x<=7);
}
}
- for 循环语句
用在循环次数已知的情况下。
public class Example{
public static void main(String[] args){
int a=0
for(int i=i;i<=9;i++){
sum+=i
System.out.println("sum="+sum);
}
}
}
循环嵌套
是指在一个循环语句的循环体中再定义另外一个循环体。用while，do…while,for循环语句都可以。
package 案例;
public class Example01 {
public static void main(String[] args) {
//打印出一个直角三角形
int i,j;//定义两个循环变量
for(i=1;i<=5;i++) { //外层循环
for(j=1;j<=i;j++) {//内层循环
System.out.print("*");//打印
}
System.out.print("\n");换行
}
}
}
跳转语句
- continue语句
它的作用终止本次循环，执行下一次循环。
public class Example{
public static void main(String[] args){
int sum =0;
for(int i=1;i<=100;i++){
if(i%2==0){
continue;
}
sum+=i;
}
System.out.println("sum="+sum);
}
}
- break语句
在switch条件语句和循环语句中都可以使用break语句。当它出现在switch条件语句中时，作用是终止某个case并跳出switch结构。但它出现在循环语句中，作用是跳出循环语句，执行后面的代码。
public class Example{
public static void main (String[] args){
int a,b;
itcast: for(a=1;a<=6;a++){
for(b=1;b<=a;b++){
if(a>2){
break itcast;
}
System.out.println("*");
}
System.out.println("\n");
}
}
}
数组常见操作
- 数组遍历
在操作数组的时，需要依次访问数组中的每个元素，这种叫做数组的遍历。
public class Exception{
public static void main(String[] args){
int[] arr ={1,2,3,4,5,6}; //定义数组
//使用for循环遍历数组的元素
for(int i=0;i<arr.length;i++){
System.out.println(arr[i]);//通过索引访问元素
}
}
}
- 数组的最值
在操作数组时，经常需要获取数组中元素的最值。
public class Exception{
public static void main(String[] args){
//定义数组
int arr[]={3,5,6,9,1,0};
//调用获取元素最大值的方法
int max=getMar(arr);
//打印最大值
System.out.pritln("max="+max);
}
static int getMax(int[] arr){
//定义变量max记住最大值，首先假设第一个元素为最大值
int max=arr[0];
//下面通过一个for循环遍历数组中的元素
for(int x=1;x<arr.length;x++){
if(arr[x]>max){//比较arr[x]的值是否大于max
max=arr[x];//条件成立，将arr[x]的值赋给max
}
}
return max;//返回最大值
}
}
- 数组排序
在冒泡排序的过程中，不断比较数组中相邻的两个元素，较小者向上浮，较大者向下沉。
public class Example{
public static void main(String[] args){
int[] arr={7,4,1,9,5,8}
System.out.println("冒泡前：");//打印数组元素
printArray(arr);//打印排序方法
bubbleSort(arr);//调用排序方法
System.out.println("冒泡排序后：");
printlnArray(arr);//打印数组元素
}
//定义打印数组的元素
public static void printArray(int[] arr){
//循环遍历数组的元素
for(int i=0;i<arr.length;i++){
//打印元素和空格
System.out.println(arr[i]+" ");
}
System.out.println("\n");
}
//定义对数组排序的方法
public static void main(String[] args){
//定义外层循环
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+1]=temp;
arr[j]=arr[j+1];
}
}
System.out.println("");
printArray(arr);//每轮比较结束打印数组
}
}
}
- 多维数组
在数组中嵌套。常见的是二维数组。
//第一种方式
int[] [] arr=new int [3] [6];
//第二种方式
int[] [] arr= new int[3] [];
//第三种方式
int[] [] arr={{1,2},{,5,6,8,9}{2,5,6}};
例如要统计一个公司3个销售小组中每个小组的总销售以及整个公司的销售额。
public class Exception{
public static void mian(String[] args){
//定义一个长度为3的二维数组
int[] [] arr=new int[3][];
//为数组的元素赋值
arr[0]=new int[]{111,12};
arr[1]=new int[]{21,22,23};
arr[2]=new int[]{31,32,33,34}
//定义变量记录总销售额
int sum=0;
//遍历素组元素
for(int i=0;i<arr;length;i++){
//定义变量记录小组销售总额
int groupSum=0;
//遍历小组内每个人销额额
for (int j=0;j<arr.length;j++){
groupSum=groupSum+arr[i][j];
}
//累加小组销售额
sum=sum+groupSum;
System.out.println("第"+(i+1)+"小组销售额为："+groupSum+"万元。");
}
System.out.println("总销售额为："+sum+"万元");
}
}
方法
它是指一段可以重复使用的代码.
例子如下
package 案例;
public class Example {
public static void main(String[] args) {
int a,b,c;//定义变量
int sum = 0;
int sum2=0;
int sum3=0;
//下面循环是使用循环语句，求a的值
for(a=3;a<=6;a++) {
sum+=a;
System.out.println("和为："+sum);
//下面循环是使用循环语句，求b的值
for(b=1;b>=5;b++) {
sum2+=0;
System.out.println("和为："+sum2);
//下面循环是使用循环语句，求c的值
for(c=2;b>=8;c++) {
sum3+=0;
System.out.println("和为："+sum3);
}
}
}
}
}
package 案例;
public class Example {
public static void main(String[] args) {
// TODO 自动生成的方法存根
int a = 0 ,b = 8,c = 5,d = 2;
int area = 0;
int area2;
while(a<=5) {
a++;
area=a*b;
System.out.println("第一个值为"+area);
}
while(c<=6) {
c++;
area2=c*d;
System.out.println("第二个值为"+area2);
}
}
}
声明方法的具体格式如下
package 案例;
public class Example {
int a,b,c;
public static int sum;
public static void main(String[] args) {
int getsum(3, 1, 2);
System.out.println("sum的值："+sum);
}
private static int getsum(int a,int b,int c ) {
sum=a%b+c;
return sum;
}
}
package 案例;
import java.io.File;
public class Example {
public static void main(String[] args) throws Exception {
int sum= getSum(4,6);//使用getSum方法
System.out.println("这个数字的和是："+sum);//输出结果
}
private static int getSum(int i, int j) { //定义方法
// TODO 自动生成的方法存根
int sum=i+j; //传入数据
return sum;//返回类型
}
}
package 案例;
public class Example {
int a,b,c;
public static int sum;
public static void main(String[] args) {
getsum(3, 1, 2);
System.out.println("sum的值："+sum);
}
private static int getsum(int a,int b,int c ) {
sum=a=b+c;
return sum;
}
}
- 修饰符：方法的修饰符比较多，有对权限进行限定的。有静态修饰符static，还有最终修饰符final
- 返回类型：用于限定调用返回值的数据类型
- 参数类型：用于限定调用方法时传入的数据
- 参数名：是一个变量，用于接收调用方法时传入数据。
- return关键字：用于结束方法以及返回方法指定类型的值。
- 返回值：被return语句返回的值，该值会返回给调用者
特别注意的是，“参数类型1 参数名1，参数类型2 参数名2 ”被称作参数列表，它用于描述方法在被调用时需要接受的参数。如果方法不需要接受任何参数，则参数类表为空，即（）内不写任何内容。方法的返回值必须为方法声明的返回类型，如果方法中没有返回值，返回类型必须声明void，此时，方法中return语句可以省略。
方法的重载
假设在程序中一个对数字不同算法，由于数字的个数和类型不同，此时要根据具体情况制定对应方法。
public class Example{
public static void main(String[] args){
int sum1=add1(1,3);
int sum2=add2(1,5,6);
double sum3=add3(2.4,5,2);
System.out.println("sum1="+sum1);
System.out.println("sum2="+sum2);
System.out.println("sum3="+sum3);
}
public static int add1(int x,int y){
return x+y;
}
public static int add1(int x,int y,int z){
return x-y*z;
}
public static int add1(double x,double y){
return x/y;
}
数组
数组是指一组数据的集合，数组中的每个数据被称作元素。数组可以存放任意类型的元素，但同一个数组存放的元素必须一致。数组可以分为一维数组和多维数组。
- 数组的定义。
int [] x=new int [9];
上语序就相当于在内存中定义了9个int类型变量，第一个变量的名称为x [0] ,第二个变量名称为x [2]…依次类推，第9个变量名称为x [8]，这些初始值都是0；
我们也可以写成这样子。
int [ ] x;//声明了一个变量，该变量类型为int[]，即一个int类型的数据
x=new int [9];
下面我们看下例子。
package 案例;
public class Example{
public static void main(String[] args){
int[] a=new int[66];
System.out.println("a[5]"+a[5]);
System.out.println("a[2]"+a[2]);
System.out.println("a[0]"+a[0]);
System.out.println("数组的长度为"+a.length);
}
}