进阶JavaSE基础01

IDEA中的快捷键

1. IDEA中格式化代码：Ctrl+Alt+L
2. 注释多行代码：Ctrl+Shift+/
3. 包不允许大写
4. ctrl+p：错误提示

2. 配置环境变量的目的：一般都是在bin文件中打开java.exe，当要在别的地方也可以使用Java时，就需要配置环境变量，总之一句话：配置环境变量的目的是可以在任何地方使用Java
3. 运行Java文件，生成可执行的class文件（Java 类名）
4. javac是编译 （编写 编译 运行）
5. 在JavaSE阶段想要运行程序，必须需要入口方法

5. JavaSE：数据类型，变量，运算符，流程控制，数组
6. JavaEE：类，对象，三大特性，接口，设计模式
7. Java程序开发：集合，IO流，多线程，异常处理，反射，网络
8. Java新特性：泛型，枚举，装箱/拆箱，Lambda表达式
9. 在Java中，char字符型一定使用单引号，String字符串一定使用双引号
10. int会把小数默认取整，所以15/2*2=14

       结果输出14，因为先做除法取整是7，乘以2就是结果14
        int a=15/2*2;
        System.out.println(a);

JavaSE

JavaSE定义了Java的基础语法结构，是为Java企业级开发打基础

Java程序工作原理

1. Java程序通过指令javac在编辑器中编译成class字节码文件，然后通过类加载器，字节码校验器和解释器翻译成操作系统认识的0，1代码
2. class既不是操作系统认识的0，1代码，也不是程序员认识的编程语言，那他是什么呢？原来有一个叫Java虚拟机jvm的东西，这个jvm认识class字节码文件，通过jvm实现Java语言的跨平台性，实现一次编译到处运行

基本数据类型

byte,short,int,long,double,float,char,booleanJava中默认类型：整型int,浮点double
12. long：如果赋值的常量超过int范围，需要在后面加L
13. float：区分double是在小数后面加F来区分

Java语言的跨平台？

1. Java程序可以运行在不同的操作系统上（Windows，centOS,mac）
2. Java程序不是直接运行的，编译器会先编译成与平台无关的字节码文件(class文件)，然后JVM会运行class字节码文件，所以在不同的操作系统下，只需安装JVM就可实现跨平台斜体样式

15. IDEA重复使用30天的使用方法，将如下的文件删除，就会重新安装IDEA

计算机存储类型

Java是强类型语言，Java中的数据要明确数据类型

1. 计算机存储（内存或硬盘）的最小单位是位（bit），存储方式是二进制,用b来表示
2. 计算机中最小的单位是字节（byte),用B来表示
3. 1B=8b;一个字节等于8个位
4. 中文（包括标点）在不同编码中是不定长2-4个字节存储（gbk汉字是两个字节，utf8汉字是3个字节）；英文（包括标点）都是一个字节存储
5. 数字一般占1个字节
   

2. 字符char

字符在存储时，会先转成ASCII码，所以赋值数值也不会出错
char data1='a';输出a
char data2=97;输出a

1. 变量的使用

		int a;
        直接报错，a未被赋值
        System.out.println(a);

自动类型转换

1. 自动转换：byte,short,int,long,double,float，是内存小容量转=为大容量，可以自动转换（虽然int和double都是4字节的，但是也可以自动转换）
2. boolean不可以与其他基本类型转换
3. 字符串和数值的转换

		可以输出99
        int h='a';
        System.out.println(h);

byte,short的加法（+）运算都会自动转为int

byte b1=10;
byte b2=20;
这行代码出错，因为b1和b2做加法时自动转为int型，因此会强转
byte b3=b1+b2;
这是正确的
byte b3=(byte)(b1+b2);

	    short a=10;
        short b=20;
        如下会报错，a+b是int型的，要强转一下
        short c=a+b;

强制类型转换(int和String)

强制类型转换格式：目标数据类型 变量名=（目标数据类型）变量名/值

int转String
		int a=123;
		String s=String.valueOf(a);
String转int,只能是数字类型的，String b="fghj"是不允许的
		String a="123";
		int i=Integer.valueOf(a);
		int i=Integer.parseInt(a);
以上这两种Integer都可以实现

1. 字符串做拼接，字符不会做拼接

char data1='A';
char data2='a';
如下是97+65，输出162
System.out.println(data1+data2);

1. ==与equals的区别：

1. 数值相等做判断，用==
2. 字符串相等做判断，用equals()

2. Scanner()用户输入

System.in是控制台输入的内容
Scanner scanner=new Scanner(System.in);
输入字符串类型
scanner.next();
输入字符串类型，也包括空格
scanner.nextLine();
输入数值
scanner.nextInt();

关键字

1. 关键字是被Java系统使用过的，书写代码定义标识符的时候都不能再次使用了
2. 关键字都是小写的
3. 在编辑器中对应的都是高亮显示，public static class等

字面量

4. 在Java开发中经常要使用数据，引入到代码中的数据叫字面量
5. 分类：数值字面量，字符字面量，字符串字面量，布尔字面量，空字面量（null）

变量

6. 变量：在运行程序过程中，可以发生变化的量，一般在内存中开辟空间，用于存储数据
7. 变量的定义 数据类型 变量名 赋值符号 值
8. 变量的使用：通过变量名来访问，在使用时必须要赋初始值，在一对大括号中不能定义两个相同的变量名

标识符

9. 书写程序时，用于给类，方法，变量来命名的符号
10. 标识符的命名规则
11. 标识符要见名知意

1. 小驼峰：变量名，方法名
2. 大驼峰：类名首字母必须大写

赋值运算符(+=)的隐藏特性

 		short s=10;
 如下会报错，因为加法运算被提升为int类型，所以将int转为short需要强转
        s=s+10；
 不会出错，隐含了强转，相当于s=(short)(s+10)
        s+=10;

逻辑运算与短路运算

1. 异或表示：两者相同为false,两者不同为true

表达式	描述
&	逻辑与
|	逻辑或
^	逻辑异或
！	逻辑非

描述	表达式
&&	短路与
||	短路或

出现问题你是如何解决的

1. 走读代码，按照逻辑分析代码，查询是否符合逻辑标准
2. 使用日志输出，对于一些变量是可变的，所以打印输出变量查询错误
3. debug可以知道代码的执行顺序，已经变量的动态改变操作

给定一个需求你是如何分析的

1. 先看输出项，这个需求要求最终的输出结果是什么
2. 确定技术选型（用分支里的if,switch,循环里的for,while等）
3. 将输入项的条件罗列出来，进行需求分析

流程控制

定义

给定不同的条件，执行不同的代码语句，得出不同的结果

分类

1. 顺序结构
2. 分支结构（if,switch）
3. 循环结构（for,while,do…while）

if和switch

4. if和switch的区别：

1. if是当有范围时使用，switch是有固定值时使用
2. if中的表达式类型是boolean, switch表达式的类型是byte,short, int, char,JDK5之后新增了枚举，JDK7新增了String

6. if有三种格式 if if..else if..else if..else
7. 格式：if(关系表达式){}，关系表达式：有关系运算符和两个变量；关系表达式的结果是布尔类型
8. 执行if..else if..else格式时，里面的条件是完全互斥的，只会执行之中一个
9. switch的格式

switch(表达式){
	case 1:
		表达式；
		break;
	case 2:
		表达式：
		break;
	default:
		表达式：
		[break]这个break可写可不写
}

双重for循环

1. for循环+switch分支循环和break
   当for循环嵌套switch循环时，使用break时只会跳出switch循环，但是for循环依然会执行
2. 双重for循环和break
   当内层for使用break时，只会跳出内层循环，对外层循环没有影响

random随机数

	Random random=new Random();
	如下会产生【0，10）间的随机数
	int i=random.nextInt(10);

内存分配

RAM:系统程序
ROM：运行的一些软件，软件会 通过以下几个 （寄存器，栈，堆，方法区（常量池，静态域））

数组

1. 为什么区分复杂数据类型和基本数据类型？因为存储空间不同
2. 引用数据类型的存储叫容器

1. 对象容器：当每个数据类型都不一样时，使用对象存储
2. 数组容器：当每个数据类型都一样时，可以使用数组存储
3. 字符串容器：只用来存储一个数据
   String name="小明"

1. 数组的定义格式：int[] arr; int arr[]
2. 只定义数组，但是没有初始化时，输出会报错 int[] arr，就像只声明int a也会出错
3. 数组的初始化：给数组中的元素开辟内存空间，且赋初始值
4. 数组的初始化方式：动态初始化，静态初始化
5. 动态初始化：（初始化数组时，只指定数组的长度，由系统为数组赋初始值）int[] arr=new int[6];系统会默认给每个元素一个初始值
   

 		int[] arr=new int[3];
        会直接输出地址
        System.out.println(arr);
        会输出0
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }

4. 静态初始化：(初始化数组时给每个元素指定初始值)String[] arr=new String[]{'1','2','3'}
5. 静态初始化的简化写法： String[] name={'1','2','3','4'};
6. 数组操作的两个常见问题：数组下标越界，空指针异常
7. 数组的排序方式：冒泡排序，选择排序和二分法排序（了解即可）

冒泡排序是比较相邻的元素
        int[] arr={20,5,3,89,102,63};
        int temp=0;
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length-1-i; j++) {
                if(arr[j]>arr[j+1]){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }

选择排序是从第一个元素开始分别与第二次，第三个比较，第二轮是第二个元素与第三个，第四个比较
   		int[] arr={20,5,3,89,102,63};
        int temp=0;
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = i+1; j <arr.length ; j++) {
                if(arr[i]>arr[j]){
                    temp=arr[i];
                    arr[i]=arr[j];
                    arr[j]=temp;
                }
            }
        }

方法

1. 类是功能的集合，类中包含方法和变量
2. 方法是可以具体实现某个功能的代码块，方法的本质：降低代码间的耦合性
3. 修饰符 返回值类型 方法名（数据类型 参数）{方法体}

	public int[] show(){
        变量名前面的都是数据类型
        int[] arr={1,2,3};
        return arr;
    }

4. void表示无返回值，可以省略return，也可以书写单独的reuturn后面直接加分号
5. 方法不能嵌套定义

    public static void main(String[] args) {
        方法不可以嵌套定义，如下在main方法中定义show直接报错
        public void show(){
            System.out.println("helloword");
        }

6. 满足什么条件可以构成重载呢？

1. 同一个类中多个方法同名
2. 方法的参数不同：个数不同，类型不同
3. 与返回值，修饰符，形参的变量名无关（不能通过返回值来判定两个方法是否是重载）

方法中参数的传递：值传递和引用传递

1. 方法中参数传递的时候才有值传递和引用传递
2. 值传递：方法中传递的参数是基本数据类型时，传递的是值，这就是值传递（调用方法参数传递，当传递的是基本数据类型，当被调用的方法对变量的值做了修改时是不会影响到原始的值的）相当于形参是在栈中重新开辟空间，所以修改方法中的形参不会对实参有影响

 public static void main(String[] args) {
        int a=10;
//        输出10
        System.out.println(a);
        show(a);
//        输出10，
        System.out.println(a);
    }
    public static void show(int a){
        a=20;
    };

3. 引用传递：方法中传递的参数是引用数据类型，传递的是地址，这就是引用传递

4. 形式参数也会在栈内存中开辟空间
5. 操作系统是如何运行程序的？

1. 运行的软件叫程序，运行程序的时候先开辟内存空间，内存中分为寄存器，栈，堆，方法区
2. 在寄存器中加载程序，只是会读取一次，并不会做什么操作
3. 栈是先进先出的，存放的是一些变量，当变量不被使用的就会被gc回收，gc是电脑自动做的
4. 堆中的数据不会被gc回收，只要new就会在堆中开辟空间（安卓是Java开发的，安装软件存储数据，内存逐渐变小，即使将软件删除内存也不会变大，因为数据已经存储到堆内存中，无法被gc回收，安卓手机上的清除内存按钮清除的是栈内存，堆中的数据无法被清除，这就是为什么安卓手机越用越卡）

6. 为什么叫引用数据类型：因为栈中引用的是堆中地址

7. 什么时候可以被gc回收？

8. 你对栈的理解？

1. 栈是先进后出的
2. 栈中有gc垃圾回收机制
3. 存储基本数据类型时，直接在栈中开辟空间存储
4. 存储引用数据类型时，存放在栈中的是堆中的地址，而真是的数据会存储到堆中

9. 你对堆的理解？

1. 堆中没有垃圾回收机制，所以内存会越用越小，即使删除了数据内存也不会恢复
2. new出来的引用数据类型都会存储到堆中，然后指向栈

调用方法时

1. 调用方法时的关注点：

1. 能否被实例化
2. 这个方法名想描述什么
3. 参数是什么