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的效果不同：

跳转控制语句：

break语句：跳出循环
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外），传递的是地址，形式参数的操作会影响实际参数