JAVA基础重点简单复习

一、认识Java的四大名词

》JDKjava Development Toolkit,java开发工具包，提供了java的开发程序，安装JDK以后，既可以运		行，也可以开发JAVA程序，JDK是整个java的核心
》JRE： Java Runtime Environment java的运行环境，面向Java程序使用者，而不是开发者，装后，只能运行java程序
》JVM： fJava Virtual Kachinc（java虚拟机）
	JVM的一部分
 》GC: Garbage Collection  java的垃圾回收机制
》 注：JDK包含JRE，JRE包含JVM

二、变量

》内存中的一小块空间，用来存放数据
》内存中的小格子如何区分的：
	》通过内存地址
	》地址不好记，所以我们可以给没一个变量取一个名字，通过变量名可以简单快速找到它存储的数据。

（2）java的数据类型

》基本数据类型和引用数据类型
》基本数据类型
	》整形：byte。short、int、long，平时基本用int
	》浮点型：float（单精度）、double（双精度），平时基本用double
	》布尔型：boolean，只有俩个值true flase
	》字符型：char 单个字符，用单引号引起来，比如‘开’，‘管’，也可以直接赋一个整数
》引用数据类型
	》类：String
	和char的区别：String类型存放字符串，0，单个，多个字符都可，
	》数组
	》接口

（3）自动类型提升
byte->short->int->long->float->double
char->int

char ch = 'a';
    int num2 = ch;
    System.out.println(num2);

short num1 = 19; //编译失败   short + int  结果为int，不能赋值给short
  num1 = num1 + 10;
num1 += 10; //不报错，因为+=有强制类型转换作用

 //编译失败,俩常量相加，判断相加结果是否在byte范围内
    //byte num2 = 126 + 4;
   byte num2 = 126; //编译正确，结果有问题
    num2 += 4;
    System.out.println(num2);//-126

（4）变量作用域

》变量的作用域在定义它的大括号内
>>根据作用域，我们可以将变量分为俩种
	》成员变量和局部变量区别
		》作用域不同
			成员变量的作用域：在整个类内都可见
			》局部变量的作用域：仅限于定义于他的方法内
		》初始值不同
			》java会给成员变量一个初始值
			》整形byte short int long，初始值为0
			》浮点数 double flaot     初始值为0.0
			》布尔型 boolean          初始值为false；
			》字符型 char			  初始值为一个空字符
			》引用数据类型String			    · 初始值是null
		java不会给局部变量初始值
		》在同一方法中，不允许有同名的局部变量
			>>不同的方法中,可以放同名局部变量
			>>俩种变量同名时,局部变量优先级更高

三、运算符和基本选择结构

四、循环结构

（1）循环结构常见错误

1.编译失败，因为循环变量没有初始化
	for（；i <10 ; i++）{
		sout（）
	}
2.编译通过，没有循环条件，造成死循环
	 for(int i = 0; ; i++){
        System.out.println(i);
    }
3.编译通过，循环变量的值无变化，造成死循环
	for（int i = 0; i < 5;  ){
		sout(i);
	}
	》可以在循环体内更新循环变量
	》可以再循环体外初始化循环变量，否则死	循环

五、数组

（1）内存

》栈内存和堆内存，是整个内存几个部分之二
》基本数据类型的变量全放在栈内存中

（2）数组

	>分步编写
		int [] nums；
		nums = new int[5];
		num[0] = 10;
		.....
		num[4] = 30;
		
	>声明和分配空间合并
		int[] nums = new int[5];
		num[0] = 10;
		....
	>声明、分配空间及赋值合并
		int [] nums = new int[] {90 .90.98};
		int[] nums ={90,90,98};

六、认识类和对象

（1）对象描述

》对象：用来描述客观事物（顾客类）的一个实体，由一组属性和方法构成
》属性
	》属性是对象具有的各种特征，每个对象的每个属性都拥有特定值
》方法
	》对象能够执行的操作
	》比如王浩可以买东西

（2）什么是类

类：类是抽象的，是模板，是具有相同属性和方法的一组对象的集合

（3）类和对象的关系

》类是抽象的概念，仅仅是一个模板，比如“人类
》一个类可以有多个对象
》对象书一个看得见摸得着的具体实体 比如某某同学

（4）封装

封装即隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别；将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。

七、方法

定义方法几个要素

	》public ...： 访问修饰符
	》void... ：   返回值类型：方法完成后完成结果的类型
	》showStudent  ...： 方法名
	》{}  ：方法体
	》（形参列表）

八、排序算法

（1）、二分法
》二分法其实就是折半查找，一种效率比较高的查找方法
》针对有序数组
  int[] nums ={2,3,4,5,6,7,8,9,10,11,12,13,14,15,100};
    int seaarchNum = 15;
    int mid ;
    int left =0;
    int right = nums.length -1;
    boolean isFind =false;
    while (left <= right){
        mid = (left + right) /2;
        if(seaarchNum > nums[mid]){
        left =mid +1;
        }else if(seaarchNum < nums[mid]){
            right =mid -1;
        }else{
            System.out.println(seaarchNum + "在数组的下标" + mid);
            isFind =true;
            break;
        }
    }
    if(!isFind){
        System.out.println("数组不包含" + seaarchNum );
    }
}

（2）、冒泡排序

将相连的俩个数进行比较，比较数组相邻 的两个值，把大的数 像泡泡一样“冒”到 数组的后面去
5个数比较4轮
比较次数 4 3 2 1
public static void main(String[] args) {
    int temp;
    int[] nums = { 24,69,80,57,13};//待排序数组
    //循环轮数
    for (int i = 0; i < nums.length -1; i++) {
        for (int j = 0 ; j < nums.length -1 -i; j++) {//每轮比较次数
           if(nums[j] > nums[j+1]){
               temp =nums[j + 1];
               nums[j + 1] = nums[j ];
               nums[ j ] = temp;
           }
        }
    }
    for (int i = 0; i < nums.length ; i++) {
        System.out.print(nums[i] + "\t");
    }
}

（3）、选择排序

选择排序用打擂台的方 式，找出最小的一个元 素，顺序放在已排好序 的数列的后面
 public static void main(String[] args) {
    int[] nums = { 24,69,80,57,13};
    for (int i = 0; i < nums.length- 1; i++) {
        for (int j = i + 1; j < nums.length; j++) {
            int temp;
            if(nums[i] > nums[j]){
                temp =nums[i];
                nums[i] =nums[j];
                nums[j] = temp;
            }
        }
    }
    System.out.println("排序后的数组");
    for (int i = 0; i < nums.length ; i++) {
        System.out.print(nums[i] + "\t");
    }
}

九、字符串相关的方法

（1）、字符串的内存分配

》String s1 = "a",首先会在常量池中查找有没有“a”这个对象。如果有机制向，没有就创建
	》创建了几个对象
		》Stirng s1 = "a"
		>?String s2 =new String("b");

（2）、注册新用户，要求免长度不能小于6位

》String类 提供了length（）的方法，用于获取字符串的长度
》获取数组长度，使用数组的length的属性names。length

（3）、登录 密码

》String类提供了equals（）的方法，比较俩个字符串的内容是否相同
》equalsIgnoreCase();不区分大戏爱哦写
》toUpperCase();转化为大写
》toLowerCase();转化为小写

（4）、==与equal 的区别

==判断俩个字符串内存地址地址值是否相同
equals比较的俩个字符串最终指向的内容是否相同

（5）、字符串连接

在表达式中  ，字符串之前 加号是运算符 遇到字符串之后编程让那个连接符
》使用String类中的concat（）方法
String num1 ="王浩";
    String num2 ="你好";
    System.out.println(num1.concat(num2));

（6）、字符串的提取结果

1.str.indexOf
2.//s在最后一次出现的位置，如果没有找到则返回-1
/*  String str = "abcabcabc"; 
    System.out.println(str.lastIndexOf("c"));*/
 3.  /* String str = "abcabcabc";
    System.out.println(str.substring(4));//从指定位置截取*/
 4.  /* String str = "abcabcabc";
    System.out.println(str.substring(3,6));*///subString( int beginIndex, int endIndex),指定区间截取字符换，左闭右开
 5.   String str = "abavfas";
    System.out.println(str.trim());//返回一个不包含任何空格的字符串

》案例：检查文件名及邮箱格式
	>>test.java
	>>[e-mail]

（7）、字符串拆分

//String 类提供了split方法，用于将一个字符串分割为一个字符串数组
    String str = "长亭外 古道边 芳草博连天";
     String[] str2 =str.split(" ");//
    for (int i = 0; i <str2.length ; i++) {
        System.out.println(str2[i]);

（8）、StringBuffer

>jie解决String类的缺点
Test05
StringBuffer 声明
	》StringBuffer sringBuffer = newStringBuffer（）；
StringBuffer str2 =new StringBuffer("b");
    System.out.println(str2);
    StringBuffer stringBuffer =new StringBuffer();
    stringBuffer.append("wanghap");
    stringBuffer.append("nihao ");
            String str = stringBuffer.toString();//数字转换成字符串 ，功能能类似于 +
    str +="ma?";
    System.out.println(str);
	
	String和StringBuffer
	String是不可变类，String每次改变都等于生成一个新的String对象
	StringBuffer可变，对原有数据进行修改，每次对StringBuffer做拼接都是对StringBuffer本身操作，胃不适创建新的对象

十、常用类了解

（1）BigDecimal类

当double运算精度不够的情况，可采用BigDecimal
double num1 = 0.02;
    double num2 = 0.03;
    System.out.println(num2 - num1);//精度不够 .00999
    BigDecimal num3 = new BigDecimal("0.02");
    BigDecimal num4 = new BigDecimal("0.03");
    System.out.println(num4.subtract(num3));//0.01
	》高精度浮点运算，表示精度更高的浮点型，位于java。math报下，该类可以进行更高精度的浮点运算
	》常用方法
		》加：add();
		>减：substract
		乘：multipaly();
		>除：divide（）

（2）Date类

》概述：
	》java。util。date类用于封装日期及时间
》获取当前系统时间
	》Date date = new Date();
》常用方法
  System.out.println(date.getYear());
    System.out.println(date.getDate());
    System.out.println(date.getDay());
	System.out.println(date.getHours());
	
	//获取日期转换事件对象
	  System.out.println(date.getTime());
    //获取日期转换对象
	SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日hh时mm分ss秒");
    String time =  simpleDateFormat.format(date);
    System.out.println(time);
	
	//将字符串转换为Date对象
    String time =  "2020-4-30";
    //要转换的字符串的格式
    SimpleDateFormat simpleDateFormat =new SimpleDateFormat("yyyy-MM-dd");
    try {
        simpleDateFormat.parse(time);
    } catch (ParseException e) {
        e.printStackTrace();
    }
    System.out.println(date);
	》》java。text。SimpleDateFormat类，是日及转换类，作用是在日期和字符串之间转换
		》format：将日期随想转换为指定格式的字符串
		》parse（）：将指定格式的字符串转换为日期对象

（4）Random类

Random》概述：java.util.Randaom主要是产生随机数，可以一个指定范围的随机数
》常用方法
	》nextInt(num);
		>生成一个随机的int值，该值介于（0,num）之间

（5）System类

》概：java。lang。System类代表系统，系统的很多属性和方法都放置在该类内部
》常用方法
	System.out,print();
	System.exit(0) 0;正常退出jvm，非0非正常退出

（6）包装类

》java是面向对象的语言，但是java的数据类型却不是面向对象的，这在实际使用过程中，会有很多布边
为了解决这个问题，在设计类的时候，给每个基本数据类设计了一个类
byte 	short	 int   		long		float	double	char	 boolean
Byte 	Short 	Intege		 Long  		Float 	Double   Character	Boolean
//int 类型转化为Ineger
    int num1 = 10;
    Integer num2 = new Integer(num1);
//        System.out.println(num2);
//        Integer对象转化为int
            Integer num3 = new Integer(20);
            int num4 = num3.intValue();
            double num5 = num3.doubleValue();
》 String str ="123";
    int num6 =Integer.parseInt(str);
    System.out.println(num6 +5);//126
    //将int型转换为字符串
    int num7 = 1000;
    String s ="" + 1000;
    String s1 = Integer.toString(num7);