java笔记–基础语法

---

JDK、JRE与JVM

第一个Java程序

//这是一个程序第三个单词与文件名必须一样
public class HelloWorld {
    //第二行是万年不变的方法，代表main方法
    //程序的入口，做Java开发一般不会改变
    public static void main(String[] args){
        System.out.println("你好，世界！");
    }
}

---

Java 基础关键字与标识符

关键字的特点：

1、完全小写的字母：public Public

2、在notpaid++中有特殊颜色

标识符

程序中自己定义的部分，如类名，方法名，变量名等都是标识符
1、标识符可以包含26个英文字母（区分大小写），数字（0~9），$（美元符号），_（下划线）
2、标识符不能以数字开头
3、标识符不能是关键字

命名规范:

1、类名规范：首字母大写后面每个单词首字母大写（大驼峰式）
2、变量名、方法名：首字母小写后面每个单词首字母大写（小驼峰式 ）

---

常量与变量

常量：

1、字符串常量：凡是用双引号引起来的的常量
2、整数常量：直接写上数字，没有小数点
3、浮点数常量：直接写上数字，有小数点
4、字符常量：只用单引号引起来的单个字符
5、布尔常量：只有两种取值，true、false。
6、空常量：null，代表没有任何数据（不能用来打印输出）

变量

程序运行期间，内容可以发生改变的量

基本数据类型

整数型：byte、short、int、long
浮点型：float、double
字符型：char
布尔型：boolean

引用数据类型

字符串、数组、类、接口、lambda

注意事项：

1、字符串不是基本类型而是引用类型

2、浮点型可能只是一个近似值，并非精确值

3、数据范围与字节数不一定相关，例如float数据范围比long更加广泛，但float是4字节，long是8字节

4、浮点数当中默认类型为double类型，如果一定要使用float类型，需要加上一个后缀F；

如果是整数，默认为int类型，如果一定要使用long类型，需要加上一个后缀L，推荐使用大写字母后缀。

System.out.println(100L);

创建一个变量并且使用的格式

• 数据类型 变量名称; //创建了一个变量
  

• 数据名称=数据值; //赋值，将左边的数据值，赋值交给左边的变量
  一步到位的格式：
  

• 数据类型 变量名 = 数据值 ; //在创建一个变量的同时，立刻放入指定的数据值
  

  public class Demo02Variable{
    public static void main(String[] args){
        //创建一个变量
        //格式：数据类型 变量名称;
        int num1;
        num1 = 10;
        System.out.println(num1);//打印10
  
        //改变变量中本来的数字，变成新的数字
        num1=20;
        System.out.println(num1);
  
        //使用一步到位的格式来定义变量
        //格式：数据类型 变量名 = 数据值;
        int num2=25;
        System.out println(num2);//打印25
  
        num2=35;
        System.out.printfln(num2);
  
        System.out.printfln("*******我是分割线******");
  
        byte num3 = 30;//注意右侧数值范围不能超过左侧的数据类型
        System.out.println(num3);//打印30
  
        byte num4 = 400;//右侧超出了byte数据范围，错误！
  
        boolean var1 = true;//布尔型变量
        var1=false;
        System.out.println(var1);
  
        boolen var2 = var1;
    }
  }

使用变量的注意对象

1、如果创建多个变量，那么变量之间的名称不可以重复。

2、对于float和long类型来说，字母后缀F和L不要丢掉。

3、如果使用byte或者short类型的变量，那么右侧的速值不能超过左侧类型的范围。

4、没有进行赋值的变量不能直接使用；一定要复赋值后才能使用。

5、变量不能超过作用域的范围。

【作用域】从定义变量的一行开始；一直到直接所属的大括号结束为止。

6、可以通过一个语句来创建多个变量，但是一般情况不推荐这么写。

数据类型转换

当数据类型不一样时，将会发生数据类型转换。

• 自动数据转换（隐式）

1、特点：代码不需要进行特殊处理，自动完成

2、规则：数据范围从小到大。（与字节数不一定相关）

public class Demo01DataType{
    public static void main(String[] args){
        System.out.println(1024);//这就是一个整数，默认就是int类型
        System.out.printfln(3.14);//这就是一个小数，默就是double类型

        //左边是long类型，右边默认int类型，左右不一样
        //一个等号代表复制，将右边的int常量，交给左侧的long变量进行存储；
        //int-->long，符合了数据范围从小到大的要求
        //这一行代码发生了自动类型转换
        int num1 = 100;
        System.out.println(num1);//输出100

        //左边double，右边float类型
        double num2 = 2.5F;
        System.out.println(num2);//输出2.5

        //左边float，右边long类型，左右不一样，发生了自动类型转换
        float num3 = 100L
        System.out.println(num3);//输出3.0
    }
}

• 强制数据转换

1、特点：代码需要进行特殊格式处理，不能自动完成。

2、格式：范围小的类型 范围小的变量名 = 原本范围大的数据（范围小的类型）原本范围

【注意事项】

1、强制类型转换一般不推荐使用，因为有可能发生精度损失、数据溢出

2、byte/short/char这三种类型都可以发生数学运算，例如加法“+”

3、byte/short/char这三种类型在运算时，都会首先提升为int类型，然后再计算

4、boolean类型不能发生数据类型转换

public class Demo02DataType{
    public static void main(String args){
        //左边是int类型，右边是long类型，不一样
        //long-->int，不是从小到大
        //不能发生自动类型转换！
        int num = (int) 100L;
        System.out.println(num);
    }
}

---

运算符

算术运算符

运算符	含义	使用方法
+	加	数值：加法； char类型字符和int类型数字：ASCII码或Unicode码相加； 字符串（string）：表示字符串连接（任何数据类型和字符串连接都会变成字符串）
-	减	减法运算
*	乘	乘法运算
/	除	除法运算，在整数运算中结果取整数
%	取模	取余数

自增/减运算符

【基本含义】让一个变量张一个数字1，或者让一个变量降一个数字1。

使用方式

1、单独使用：不和其他任何操作混合，自己独立成为一个步骤。

2、混合使用：和其他操作混合使用。

赋值运算符

基本赋值运算符：就是一个等号“=”，代表将右侧的数据交给左侧的变量。

复合赋值运算符：

+=

运算符	含义
+=	加等于
-=	减等于
*=	乘等于
/=	除等于
%=	取模等于

• 复合运算符中隐含着一个强制类型转换

比较运算符

运算符	含义
==	比较符号两边数据是否相等，相等时结果为true
<	比较符号左边数据是否小于右边数据
>	比较符号左边数据是否大于右边数据
<=	比较符号左边数据是否小于等于右边数据
>=	比较符号左边数据是否大于等于右边数据
!=	比较符号两边数据是否相等，不相等时结果为true

//比较运算符
public class Demo01Operator{
    public static void main(String[] args){
        System.out.println(10 > 5);
        int num1 = 10;
        int num2 = 20;
        System.out.println(num1 > num2);
    }
}

【注意事项】

1、比较运算符的结果一定是一个boolean值，成立就是true，不成立就是false。

2、如果进行多次判断，不能连着写。

逻辑运算符

与（并且）&& 全都时true，才是true；否则就是false

或（或者）||至少一个是true，就是true

非（取反）！本来是true，变成false；本来是false，变成true

与“&&”，或“||”，具有短路效果：如果根据左边已经可以判断得到最终结果，那么右边的代码将不再执行，从而节省一定的性能

1、逻辑运算符只能用于boolean值。 2、与、或需要左右格斯有一个boolean值，但是取反只要有唯一的一个boolean值即可。 3、与、或两种运算符如果有多个条件可以连续写。

三元运算符

需要三个数据才可以进行操作的运算符

格式：

数据类型 变量名 = 条件判断 ? 表达式A : 表达式B;

流程：

首先判断条件是否成立:

如果成立为true，那么将表达式A的值赋值给左侧的变量;

如果不成立为false，那么将表达式B的值赋值给左侧的变量;

二者选其一。

注意事项:

1.必须同时保证表达式A和表达式B都符合左侧数据类型的要求。

2.三元运算符的结果必须被使用。

public class Demo100perator {
    public static void main(string[]args) {
       int a = 10;
       int b = 20; 

       //数据类型变量名称=条件判断?表达式A:表达式B;
       //判断a >b是否成立，如果成立将a的值赋值给max;如果不成立将b的值赋值给max。二者选其一

       int max = a > b ? a : b; //最大值的变量
       System.out.println("最大值:" +max); //输出 20

       // int result = 3 > 4 ? 2.5 : 10;//错误写法!

       System.out.println(a > b ? a : b);//正确写法!

       // a> b ? a : b;//错误写法!
    }
}

---

方法

我们在学习运算符的时候，都为每个运算符单独的创建一个新的类和main方法，我们会发现这样编写代码非常的繁琐，而且重复的代码过多。能否避兔这些重复的代码呢，就需要使用方法来实现。

• 方法:就是将一个功能抽取出来，把代码单独定义在一个大括号内，形成一个单独的功能。

当我们需要这个功能的时候，就可以去调用。这样即实现了代码的复用性，也解决了代码冗余的现象。

public class Demo11Method {
    public static void main(String[]args){
        farmer(); //调用农民的方法
        seller(); //调用小商贩的方法
        cook(); //调用厨子的方法
        me(); //调用我自己的方法工

    }
}

//我
public static void me(){
   system.out.println("吃"); 
}


//小商贩
public static void seller() {
    system.out.println("运输到农贸市场");
    System.out.println("抬高价格");
    system.out.println("吆喝");
    System.out.println("卖给厨子");
}


//农民伯伯
public static void farmer(){
    System.out.println("播种");
    system.out.println("浇水");
    System.out.println("施肥");
    system.out.println(""除虫");
    system.out.println("收割");
    system.out.println("卖给小商贩");
}

定义方法的完整格式:

修饰符 返回值类型 方法名称(参数类型参数名称，...) 
    方法体
    return返回值;
}
/*
修饰符:现阶段的固定写法:public static

返回值类型:也就是方法最终产生的数据结果是什么类型
方法名称:方法的名字，规则和变量一样，小驼峰
参数类型:进入方法的数据是什么类型
参数名称:进入方法的数据对应的变量名称
    Ps:参数如果有多个，使用逗号进行分隔
方法体:方法需要做的事情，若干行代码
return:两个作用，第一停止当前方法，第二将后面的返回值还给调用处
返回值:也就是方法执行后最终产生的数据结果

注意:return后面的“返回值”，必须和方法名称前面的“返回值类型”，保持对应。
*/

【注意事项】

1、方法定义的先后顺序无所谓。

2、方法定义不能产生嵌套包含关系。

3、方法定义好了以后，不会执行的，如果要执行，一定要进行方法的调用。

如何调用方法，格式：方法名称();

方法的重载

对于功能类似的方法来说，因为方法不一样，却要记住那么多不同的方法名称，太麻烦。

方法的重载（OverLoad）：多个方法的名称一样，但是参数列表不一样。

好处：只需要记住一个方法名称就可以实现类似的功能。

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

• 参数个数不同
  
• 参数类型不同
  
• 参数的多类型顺序不同
  

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

• 与参数的名称无关
• 与方法的返回值类型无关

public class Demo01MethodOverlode {
    public static void main(String[] args) {
        System.out.println(sum(10,20));
        System.out.println(sum(10,20,30));
        System.out.println(sum(10,20,30,40));
    }

    public static int sum(int a,int b)
    {
        System.out.println("有两个参数的方法执行！");
        return a+b;
    }

    public static int sum(int a,int b,int c)
    {
        System.out.println("有三个参数的方法执行！");
        return a+b+c;
    }
    public static int sum(int a,int b,int c,int d)
    {
        System.out.println("有四个参数的方法执行！");
        return a+b+c+d;
    }
}

---

数组

数组的初始化:在内存当中创建一个数组，并且向其中赋子—些默认值。
两种常见的初始化方式:

• 动态初始化（指定长度）:在创建数组的时候，直按指定数组当中的数据元素个数
• 静态初始化（指定内容）:在创建数组的时候，不直接指定数据个数多少，而是直接将具体的数据内容进行指定。

动态切始化数组的格式:

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

解析含义:

左侧数据类型:也就是数组当中保存的数据，全都是统一的什么类型

左恻的中括号，代差我是—个数组

左彻数组茗称:给数组取一个名字

右彻的new:代表创建数组的动作

右侧蛟据类型:必须和左边的致据类型保持一致

右侧中括号的长度:也就是数组当中，到底可以保存多少个数据，是一个int数字

public class Demoe1Array {

    public :tatic.void main(stringl]args)i
        //创建一个数组，里面可以存放300个int数据
        //格式:数据共型数组名称 = new 数据类型[数组长度];
        int [] arrayA = new int[300];
}

静态初始化基本格式:

/*数据类型 [] 数组名称 = new 数据类型[] {元素1，元素2,……};*/

public class Demo02Array {
    public static void main(String[] args) {
        //直接创建一个数组，里面装的全都是int数字，具体为: 5、15、25
        int[] arrayA = new int[] { 5, 15, 25 };
        //创建一个数组，用来装字符串: "Hello"、 "World"、 "Java'
        String[] arrayB = new String[] { "He11o"， "World", "Java" };
    }
}

【注意事项】

虽然静态初始化没有直接告诉长度，但是根据大括号里面的元素具体内容，也可以自动推算出来长度。

使用静态初始化数组的时候，格式还可以省略一下。

标准格式:

数据类型[] 数组名称= new 数据类型[] {元素1,元素2，… };

省略格式:

数据类型[] 数组名称= {元素1,元素2, … };

【注意事项】

• 静态初始化没有直接指定长度，但是仍然会自动推算得到长度。
• 静态初始化标准格式可以拆分成为两个步骤。
• 动态初始化也可以拆分成为两个步骤。
• 静态初始化一旦使用省略格式，就不能拆分成为两个步骤了。

【使用建议】

如果不确定数组当中的具体内容，用动态初始化;否则，已经确定了具体的内容，用静态初始化。

public class Demo03Array {
    public static void main(String[] args) {
        //省略格式的静态初始化
        int[] arrayA = { 10，20，30 };
        //静态初始化的标准格式，可以拆分成为两个步骤
        int[] arrayB;
        arrayB = new int[] { 11, 21, 31 };
        //动态初始化也可以拆分成为两个步骤
        int[] arrayC;
        arrayC = new int[5] ;
        }

}

动态初始化时，其中元素会自动拥有一个默认值

整形数据：0

浮点型数据：0.0

字符型数据：’\u0000’

布尔类型：false

引用类型：null

【注意事项】

静态初始化其实也有默认值，只不过立马被替换成了大括号里面的具体值而已。

Java的内存需要划分5个部分

栈（stack）：存放的都是方法中的局部变量

==方法的运行一定要在栈当中运行。==

局部变量：方法的参数，或着是方法{}内部的变量
作用域：一旦超出作用域，立刻从栈内存中消失

堆（Heap）:==凡是NEW出来的东西都在堆当中==

堆内存里面的东西都有一个地址值：16进制

堆内存里面的数据都有默认值，规则：

• 如果是整数 默认为0
• 如果是浮点数 默认为0.0
• 如果是字符 默认为 ‘\u0000’
• 如果是布尔 默认为false
• 如果是引用类型 默认为null

方法区（MethodArea）存属.class相关信息，包含方法的信息。

本地方法栈（Native Method Stack）：与操作系统相关。

寄存器：与CPU相关。

如何获得数组长度

格式：数组名称.length

将会得一个int数字，代表数组长度

数组一旦创建,程序运行期间长度不可改变

数组可以作为方法的参数

当调用方法的时候，向方法的小括号进行传参，传递进去的其实是数组的地址值。

数组作为返回值

一个方法可以有多个参数但是只有0~1个返回值，不能有多个返回值，如果希望一个方法中产生了多个结果数据进行返回，怎么办？

解决方法：使用一个数组作为返回值类型即可。

public class Demo03ArrayReturn {
    public static void main(String[] args) {
        int x=50,y=30,z=20;
        int[] result = calculate(x,y,z);
        System.out.println(result[0]);
        System.out.println(result[1]);
    }
    public static int [] calculate(int a,int b,int c){
        int sum=a+b+c;//总和
        int avg=sum/3;//平均数
        //两个数都希望进行返回
        int[] array=new int [] {sum,avg};
        return array;
    }
}