java基础(1)

zoukankan html css js c++ java

java基础(1)
1.常量

常量是指程序运行期间，内容不可发生改变的量，像10，10.2，“hello”等都是常量

2.变量

变量与常量相反，程序运行期间，可以在一定范围内发生改变的量就是变量，变量的本质其实就是用来存放数据的一小块内存空间

变量的格式：数据类型变量名 = 数据值

标识符的规则：
- 只能由字符、下划线_和美元符$组成
- 不能以数字开头s
- 不能是java的关键字
常见的标识符命名规则（软性建议）：
- 见名只其意
- 只使用英语和数字，更不要使用拼音
- 类：每个单词首字母大写, 如Hello
- 变量第一个单词完全小写后续更多单词首字母大写（小驼峰式），如ageOfLuyi
- 方法：与变量规则一样，如show(),getAge()
- 包：其实就是文件夹，由于对类进行管理，命名建议为全部小写，多级包用点.隔开
变量的注意事项：
- 创建的多个变量不能重名
- 变量一定要赋值之后才能使用
- 变量的作用域问题：变量定义在哪个大括号中，就只能在哪个大括号中使用，超过所属的大括号，就无法使用
- 可以在一个语句中同时定义类型相同的多个变量
3.数据类型的分类

基本类型
- 整数类型：byte(占一个字节) short（占2个字节） int（占4个字节） long（占8个字节）
- 浮点类型:float（占4个字节） double（占8个字节）
- 字符类型:char（占2个字节）
- 布尔类型:boolean（占1个字节）
引用类型
- 字符串
- 类
- 接口
- 数组
- Lambda
- ...
注意事项：
- 整数类型默认为int类型
- 浮点数类型默认为double类型
- 定义一个long型数据，在数值后面要用字母L作为后缀（大小写都可以，推荐使用大写），如5000L
- 定义一个float型数据，在数值后面要用字母F作为后缀（大小写都可以，推荐使用大写），如3.14F
- 字符char型数据，是可以包含中文的
4.运算符

运算符：对常量或变量进行操作的符号，叫做运算符，例如“+”
表达式：用运算符将多个常量或变量连起来的式子，叫做表达式，例如“a+b”
常用的运算符：

算数运算符：

1.加号（+）：跟数学中的加法一样，但是+对于字符串来说，并不是相加的意思，而是连接的功能，需要注意优先级问题
```
String str5 = "abc" + 10 + 20
//结果为：abc1020
String str5 = "abc" + (10 + 20)
//结果为：abc30
```
2.减号（-）

3.乘号（*）

4.除号（/）这里的除号是整除，只看商，不看余数

5.求余（%）：取模运算，取得余数，只看余数，不看商

6.自增运算符（++）：在变量的原有基础上加1，可以写在变量前面，也可以写在变量后面

a.单独使用的时候：前++和后++无任何区别

b.如果和其他运算符混合使用时：如果是前++，那么变量马上+1，然后拿着结果进行使用，如果是后++，那么首先使用当前的本来数据，然后再进行+1操作
- 自减运算符（--）：在变量的原有基础上减1
- 计算中如果有小数参与，那么结果一定是小数
赋值运算符
- 基本赋值运算符：表示将右侧的数值赋给左边的变量
- 复合赋值运算符：如 a += 3,a *= 4
- =左侧不能是常量，右侧既可以是常量也可以是变量
比较运算符：比较运算符的结果一定是一个布尔值，要么为true，要么为false
- 大于 >：
- 小于 <：
- 大于等于 >=
- 小于等于 <=
- 不等于 !=
- 等于 ==
逻辑运算符：
- 与（&）：全为true才为true
- 或（|）：有一个true就是true
- 异或（^）：相同是true，不同是false
- 非取反（！）：本来true变成false,本来是false变为true
- 短路使用：如果左侧已经可以判断到最终结果，那么右侧将不再执行
  
  短路与（&&）
  
  短路或（||）
位运算符（了解）

^的特殊使用：两次异或不改变原值

位运算可能会出现的面试题：

A:请实现两个变量的交换：用位异或运算符实现

a = a^b; b = a^b; a = a^b

B:请用最有效率的方式计算出2乘以8的结果

2<<3

5.Scanner键盘输入

使用引用类型的三个步骤：

1.导包：指定需要使用的目标在什么位置，在public class之前写一行代码 import 包路径名
```
import java.util.Scanner;
```
2.创建：数据类型变量名称 = new 数据类型（）
```
Scanner sc = Scanner(System.in);
```
3.使用：变量名称.方法名（）；
```
String str = sc.next()
	int num = sc.nextInt()
```
总代码：
```
import java.util.Scanner;
public class Sc{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("please input something");
        String str = sc.next();
        System.out.println(str);
    }
}
```
6.流程

顺序结构：程序自上而下一条线走下来

选择结构（if-else）:

1.单if语句
```
if(布尔表达式){
	语句体；
}
//如果布尔表达式为true，则执行语句体，否则，不执行；
```
2.标准if-else语句
```
if(布尔表达式){
语句体A；
}else{
    语句体B;
}
//如果布尔表达式为true，则执行语句体A，否则，执行语句体B；
```
3.扩展if-else语句
```
if(布尔表达式1){
    语句体A；
}else if(布尔表达式2){
    语句体B;
}
...
else if(布尔表达式N){
    语句体N
}else{
    语句体N+1
}
```
例子：求两个数的最大值
```
import java.util.Scanner;
public class MaxNumber{
    public static void main(String[] arg){
        Scanner sc = new Scanner(System.in);
        System.out.println("please the num1: ");
        int num1 = sc.nextInt();
        System.out.println("please the num2: ");
        int num2 = sc.nextInt();
        if(num1 > num2){
           System.out.println("the max number is" + num1);
       }else{
           System.out.println("the max number is" + num2);
       }
	}
}
```
选择结构（switch）:

格式：

switch(表达式){
case 值1:
语句体1；
break;
case 值2:
语句体2；
break;
...
default:
语句体n + 1;
break;
}

格式解释说明：

1.switch:说明这是switch语句

2.表达式：可以是byte,short,int,char,不可以是long，JDK5之后可以是枚举，JDK7以后可以是字符串

3.case:后面的值就是要和表达式进行比较的值

4.break:表示程序到这里中断，跳出switch语句

5.default：如果所有情况都不匹配，就执行这里，相当于if语句中的else

执行流程：

1.首先计算表达式的值

2.和每一个case语句进行匹配，如果有匹配的就执行对应的语句体，看到break就结束

3.如果没有匹配到，就执行default的语句n+1

注意事项：

1.case后面只能是常量，不能是变量，而且，多个case后面的值不能出现相同的

2.default可以省略，但是不建议，因为它的作用就是对不正确的情况给出提示

3.break可以省略，但是结果可能不是我们想要的，会出现case穿透的现象，所以不推荐省略

4.default不一定要在最后，可以是任意位置，但是建议放在最后

5.switch语句结束的条件
- 遇到break就结束
- 执行到末尾就结束
示例代码：
```
import java.util.Scanner;

public class Demo11 {
	public static void main(String[] args) {
		System.out.println("请输入一个数字（1-7）");
		Scanner sc = new Scanner(System.in);
		int day = sc.nextInt();
		String week = null;
		switch(day){
		case 1:
			week = "一";
			break;
		case 2:
			week = "二";
			break;
		case 3:
			week = "三";
			break;
		case 4:
			week = "四";
			break;
		case 5:
			week = "五";
			break;
		case 6:
			week = "六";
			break;
		case 7:
			week = "天";
			break;
			default:
				System.out.println("数据错误！");
		}
		System.out.println("今天星期" + week);
	}
}
```
循环结构

循环结构的组成部分
- 初始化语句：这部分内容最先执行，而且仅执行一次；
- 条件判断：如果成立，则循环继续，如果不成立，则循环中止；
- 循环体：每次循环都将重复执行循环体的代码内容；
- 步进语句：每次循环执行后，都会执行一次步进语句；
for 循环：通常用于控制次数的场景
```
for(初始化语句；条件判断，步进语句){
	循环体；
}
```
例子：求出1-100的偶数和
```
public class EvenNumber{
    public static void main(String[] arg){
        int sum = 0;
        for(int i = 1; i < 101; i ++){
            if(i % 2 == 0){
                sum += i;
            }
        }
        System.out.println("the sum is: " + sum);
    }
}
```
whlie循环：
```
标准模式：
while(条件判断){
	循环体；
}
//当条件满足时执行循环体，不满足则跳出循环体

扩展模式：
初始化语句；
while(条件判断){
	循环体；
	步进语句；
}
```
例子：求1-100的奇数和
```
public class OddNumber{
    public static void main(String[] arg){
        int sum = 0;
        int i = 1;
        while( i < 101){
            if(i % 2 == 1){
                sum += i;
            }
            i ++;
        }
        System.out.println("the sum is: " + sum);
    }
}
```
for循环与while循环的区别：for循环的步进语句还能接着走，而whlie的步进语句由于continue跳出了循环，导致剩余内容的步进语句也没被跳过
```
public class ContinueDemo{
    public static void main(String[] arg){
        for(int i = 1; i < 10; i ++){
            if(i == 4){
                continue;
            }
            System.out.println(i);
        }
        System.out.println("=====================");
        int i = 1;
        while(i < 10){
            if(i == 4){
                continue;
            }
             System.out.println(i);
             i ++;
        }
    }
}
//输出结果为：
1
2
3
5
6
7
8
9
=====================
1
2
3
```
1.for循环格式固定，控制次数更方便，而while循环格式更加灵活，不在意循环次数，循环次数确定的使用for较多，次数不确定，使用while较多

2.for循环小括号内定义的变量，循环内可用，循环外不可用，while循环的初始化表达式本来就在外面，仍然可用

3.跳转语句continue的效果不同：

跳转控制语句：
1. break语句：跳出循环
2. continue语句：只跳出本次循环，后续还要继续循环
死循环（永真循环）：
这两种方法可以实现死循环
```
while(true){
}
for(; ;){
}
```
嵌套循环：
```
//打印一天中所有可能出现的时：分
public class Clock{
    public static void main(String[] arg){
        for(int i = 0; i < 24; i ++){
            for(int j = 0; j < 60; j ++){
                System.out.println(i +":" + j);
            }
        }
    }
}
```
7.集成开发环境（IDE）

我们这里介绍Eclipse,因为他是完全免费的

Eclipse IDE基本特点：
- 完全免费
- 完全开源
- java语言编写
- 绿色软件：解压就能用，不用安装
- 扩展性很强
下载：官网：http://www.eclipse.org
安装：解压就可直接使用
卸载：删除从官网下载的文件夹即可

Eclipse使用的常用快捷键
- 添加单行注释：Ctrl + / 取消：Ctrl + /
- 添加多行注释：Ctrl + Shift + / 取消：Ctrl + Shift + /
- 向上向下复制一行：Ctrl+Alt+向上/向下
- 向上向下移动一行：Alt+向上/向下
- 删除当前行：Ctrl+D
- 格式化：Ctrl+Shift+F
- 智能提示：Alt+/
8.数组的使用

概述：数组是一种引用类型。变量只可以存放一个数据，数组则可以存放多个类型统一的数据，可以存放基本类型，也可以存放引用类型；

数组的格式：
- 数据类型[] 数组名称；
- 数据类型数组名称[];(不推荐)
数组的初始化：使用之前一定要先初始化

1.动态初始化：指定数组的长度
```
//创建了一个可以存放三个数据的int类型的数组array1
int array1 = new int[3]
```
2.静态初始化：指定数组的内容，会自动根据内容推算出数组的长度
```
/*标准格式, 标准格式可以拆分为
int array2[];
array2[] = new int[]{1, 2, 3};*/
int array2[] = new int[]{1, 2, 3};
System.out.println(array1);
/*简便格式,不可以拆分为
int array3[];
array3 = {1, 2, 3};*/
int array3[] = {1, 2, 3};
```
数组的访问：
- 直接打印array1会得到一个包括地址值，如[I@15db9742
- 打印array1[0]:会得到数组中索引为0的值，数组的索引也就是数组中元素的编号，编号从0开
数组的默认值：

当你没有给数组赋值的时候，数组会有自己的默认值，不同数据类型的数组会有不同，整数类型的数组的默认值为0，布尔值类型的数组的默认值为false，浮点类型的数组的默认值为0.0

数组获取长度：数组名称.length,当一个数组在内存中被创建了的时候，那么数组的长度旧不能发生改变

数组在堆栈中存放的情况：

二维数组：元素是一维数组的数组

1.格式：

A.数据类型[][] 数组名 = new 数据类型[m][n];

B.数据类型[][] 数组名 = new 数据类型[m][];

C.数据类型[][] 数组名 = new 数据类型[][]{{...},{...}};

D.数据类型[][] 数组名 = {{...},{...}};

9.java内存分配

栈（Stack）：主要用来存放局部变量

堆(Heap)：凡是new出来的东西，都在堆当中，都有地址，堆当中的数据有默认规则：

如果是整数，默认是0

如果是浮点数，默认为0.0

如果是字符，默认是‘u0000’(Unicode写法)

如果是布尔值:默认是false

如果是引用类型（包括Striing），默认是null（空常量）

数据使用完毕后，在垃圾回收器空闲的时候回收

方法区（Method Area）：

与面向对象的知识点相关，再后面详说

本地方法区(Native Method)：

与操作系统相关

寄存器(Register)：

与CPU相关，性能极高

10.方法

概述：对于一些复杂的代码逻辑，如果希望重复使用这些代码，并且做到“随时任意使用”，那么就可以将这些代码放在一个大括号“{}”之中，并且起一个名字，使用代码的时候，直接找到名字调用即可；

方法的格式：
```
修饰符 返回值类型 方法名称（参数类型 参数名称）{  
	方法体；  
	return返回值；  
}
```
解释：
- 修饰符：目前就用public static，后面再详细讲解其他修饰符
- 返回值类型：方法最终产生的数据是什么类型
- 方法名称：自定义的名字，规则和变量一样
- 参数类型：进入方法的数据是什么类型
- 参数名称：进入方法的数据，对应的变量名称
- 方法体：需要执行的若干代码
- return:有两个作用，结束当前方法和带着后面的返回值交给调用处
- 返回值：方法的最终数据结果
注意事项：
- 返回值类型必须和返回值对应
- 如果参数有多个，那么使用逗号隔开
- 如果不需要参数，那么小括号内可以留空
调用方法的三种方法：
- 单独调用：格式为方法名称（参数值），这种调用无法使用方法中的返回值
- 打印调用：格式为 System.out.println(方法名称（参数值）)，调用方法，并把返回值打印出来
- 赋值调用：格式为数据类型变量名称 = 方法名称（参数值），注意变量的数据类型必须和方法的返回值数据类型一致
有返回值的方法的例子：求两个数之和
```
public class Demo2 {
public static int plus(int num1, int num2){
	return (num1 + num2);
}

public static void main(String[] args) {
	int sum = plus(3, 4);
	System.out.println("the sum is: " + sum);
}
```
}

关于名称的两个问题：
- 变量的名称能不能和方法的名称一样？可以
- 如果有两个方法，每一个方法当中都有一个同名的变量，是否可以？可以，虽然名称相同，但是他们是两个变量
没有返回值的方法格式：没有返回值的时候，只能使用单独调用，不能使用打印调用或赋值调用
```
修饰符 void 方法名称（参数类型 参数名称）{  
	方法体；  
	return；//最后一行的return可以省略不写  
}
```
无返回值的方法的例子（遍历数组并打印出来的方法）：
```
public class Demo3 {
	public static void arrayMethod(int[] array){
		for(int i = 0; i < array.length; i ++){
			System.out.println(array[i]);
		}
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] array1 = {1, 2, 3};
		arrayMethod(array1);
	}
	
}
```
方法的重载：

1.问题描述：对于类似的多个方法，全都是执行相加的操作，但是因为参数列表不一样，所有要记住很多名字，太麻烦

2.解决方案：使用方法的重载技术，可以达到效果，对于类似功能的多个方法，只要记住一个相同的方法名即可，可以根据参数列表的不同自动适配

3.方法重载（Overload）：方法的名称相同，但是参数列表不同(包括参数个数不同，参数类型不同，参数的多类型顺序不同)

重载的例子：
```
public class Demo4 {
	public static void main(String[] args) {
		int sum1 = Plus(1, 2);//3
		int sum2 = Plus(1, 2, 3);//6
		int sum3 = Plus(1, 2, 3, 4);//10
		System.out.println(sum1 + " " + sum2 + " " + sum3);
	}
	public static int Plus(int a, int b){
		return a + b;
	}
	public static int Plus(int a, int b, int c){
		return a + b +c;
	}
	public static int Plus(int a, int b, int c, int d){
		return a + b + c +d;
	}
}
```
重载的注意点：

1.无法根据参数的名称进行重载，当两个方法的参数名不同，但是功能完全一样时，不能进行重载

2.无法根据返回值类型的不同进行重载，当两个方法的返回值类型不同时，也不能进行重载

参数传递：

1.概述：在调用方法的时候，向方法内传入一些数据的动作

2.形式参数与实际参数：在定义方法的时候，写在小括号里面的参数就是形式参数，而在调用方法时，真正传入方法里的数据就叫做实际参数

3.参数传递的过程的两项规则：对于基本数据类型（以及String）来说，传递的是值，形式参数的操作不会影响实际参数；而对于引用类型（除String外），传递的是地址，形式参数的操作会影响实际参数
查看全文

相关阅读:
SpringMVC中静态获取request对象 Spring中获取 HttpServletRequest对象【转载】
springcloud 的loadbalancer 轮询算法切换方法 2021.4.3
springboot项目启动增加图标
 rabbitmq 端口作用以及修改方法
 centos8 安装rabbitmq
springcloud config client Value获取不到信息的问题的处理方法
 springcloud config配置git作为数据源然后启动报错 If you want an embedded database (H2, HSQL or Derby), please put it on the classpath.
Sublime Text的列模式如何操作
 centos8 安装redis
jQuery简单的Ajax调用

原文地址：https://www.cnblogs.com/luyi001/p/13307134.html

1.常量

2.变量

3.数据类型的分类

4.运算符

算数运算符：

赋值运算符

比较运算符：比较运算符的结果一定是一个布尔值，要么为true，要么为false

逻辑运算符：

位运算符（了解）

5.Scanner键盘输入

6.流程

顺序结构：程序自上而下一条线走下来

选择结构（if-else）:

选择结构（switch）:

循环结构

7.集成开发环境（IDE）

8.数组的使用

数组的格式：

数组的初始化：使用之前一定要先初始化

数组的访问：

数组的默认值：

二维数组：元素是一维数组的数组

9.java内存分配

栈（Stack）：主要用来存放局部变量

堆(Heap)：凡是new出来的东西，都在堆当中，都有地址，堆当中的数据有默认规则：

方法区（Method Area）：

本地方法区(Native Method)：

寄存器(Register)：

10.方法