华清远见重庆中心Java基础阶段技术总结

Java基础

Java概述

Java是在1995年由SUN公司发布的一门半编译半解释的面向对象的语言。由于Java中有虚拟机JVM的存在，所以它可以跨平台使用。

Java分为：JavaME(Java微型版)、JavaEE(Java企业版)、JavaSE(Java标准版)

JavaSE是Java的核心和基础，也是Java EE和JavaME的核心.

Java的优点：简单、安全、开源、多线程、半解释半编译、面向对象。

Java的一个核心：JVM（Java虚拟机），它用于解释Java的字节码文件。

JDK和JRE

JDK（Java开发工具包），包含了JRE、Java的调试、编译等工具。

JRE（Java运行环境），包含了JVM，Java运行工具等。

JDK中包含了JRE和JVM。

编写第一个Java程序

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

Java代码中的注意事项

1、写代码，必须创建class，class称为类，是一个Java程序的基本组成单位。

2、符号：Java中的符号全部都是英文状态下的符号。"{}"用于定义类、定义方法和代码块,"[]"用于定义、使用数组,"()"用于表示方法的参数,"空格"用于分割关键字和代码,"."用于调用某个类或对象的属性、方法,";"用于表示一句代码的结束。

编程语言的命名规则

驼峰命名方法：

如果多个单词描述一个内容，除首字母外，其他单词首字母大写。例如：studentClass

帕斯卡命名法：

所有单词首字母全部大写。例如：StudentName

Java中的标识符及命名规则

Java中的类名、方法名和变量名统称为标识符

类名使用帕斯卡命名法。方法名、变量名使用驼峰命名法。命名时要做到见名知意

命名规则：1、标识符使用字母、数字、下划线和$组成

                   2、不能以数字开头

                   3、不能使用Java中的关键字（保留字）

                                                              关键字列表

 Java中的数据类型

分为：原始(基本)类型和引用类型

原始类型：

整型（byte、int、short、long），浮点型（float、double）、字符型(char)

 注意：在程序中写出整型，默认是int类型，写出小数，默认是double类型。

原始类型之间的数据类型转换

分为隐式类型转换（自动类型转换）：占用字节小的数据类型的变量，可以直接保存到占用字节大的数据类型的变量中

short s=1;
int i=s;
//s是short类型，占两个字节，i是int类型，占四个字节

显式类型转换（强制类型转换）

语法：（目标类型）带转化的变量

int num=23;
byte i=(btye)num;//强制转换为byte类型
//如果待转换的变量中的数据能正常保存到转换的目标变量中，结果无误。
//如果超出目标变量的范围，会造成数据溢出。
byte n=(byte)128;//数据溢出

引用数据

类、接口、数组。

变量

变量是在内存中的一块区域。由于这块区域中的数据可以发生变化，所以称为变量。

定义变量

定义变量，就是在内存中申请一块相应数据类型的空间，并对其命名的过程。

语法： 数据类型  变量名；或  数据类型  变量名1，变量名2.......;

int num;
int a,b,c;

变量赋值

语法：变量名 = 值；

int num;
num=12;

变量初始化

语法：数据类型 变量名 =值；

int a=2,b=3,c=4;

注意事项：

一对大括号(一个作用域)中，变量名不能重复。

public class Hello {
    public static void main(String[] args) {
        int a=20;//可以
        int a=20;//不可以
        int A=20;//可以
    }
}

变量赋值时，=左边通常是一个变量名，右边可以是一个具体值、另一个已赋值的变量名、一个表达式。保证=右边的数据类型能被等号右边接纳。

int age=20;
int b=age;
boolean flag=2>1;

如果同时定义多个类型相同的变量，可以只写一个数据类型

int a=20,b=6;

运算符

算术运算符

 注意：如果同时多个符号一起使用，遵循数学中的四则运算规则，先乘除，再加减。

运算时最终结果的数据类型，以所有参与运算的操作数中所占字节最大的类型为准。

关系运算符 

>	大于	>=	大于等于
<	小于	!=	不等于
<=	小于等于	==	等于

注意：

==用于判断相等，=用于赋值

==用于比较两个原始类型的值或引用类型的内存地址

关系运算的结果为true/false

逻辑运算符

 

赋值复合运算符

int a+=6;//a=a+6

自增自减运算符

++:将结果+1。--：将结果-1

注意：a++或++a相当于a+=1或a=a+1。--同理

如果++或--独立成行使用，无论符号在前在后，都将结果+1或-1

如果++或--不是单独成行

       符号在前，先+1或-1计算后在使用值

        符号在后，先使用值再进行+1或-1计算

条件运算符

又称三木运算符，有三个操作数参与

格式： 表达式1？表达式2：表达式3

先运算表达式1，如果结果为true，执行表达式2，如果结果为false,执行表达式3。最终结果为表示2或表达式3.

运算符的优先级

小括号>单目运算符>算术运算符>关系运算符>逻辑运算符>条件运算符>赋值复合运算符

使用条件运算符判断闰年

        int year;
        System.out.println("请输入一个年份");
        year=sc.nextInt()
        String t=(y31ear%4==0&&year%100!=0)||year%400==0?"闰年":"不是闰年";
            System.out.println(t);

条件语句

单分子if语句

if(判断条件){
//判断条件的结果为布尔值
条件满足时执行的代码
}

双分支if语句

if(判断条件){
    条件满足则执行代码
}else {
    条件满足执行代码
}

多分支if语句

if(判断条件1){

如果判断条件1满足时执行
}else if(判断条件2){
如果判断条件2满足时执行
}else if(判断条件3){
如果判断条件3满足时执行
}else{
如果所有条件都不满足时执行
}

switch语句

switch(变量){//要判断的变量，只能是非long整型、字符型char和字符串String和枚举类型
case 值:
//如果变量的值与当前case的值匹配，执行这里的代码
break;
case 值:
//如果变量的值与当前case的值匹配，执行这里的代码
break;
...
default:
//如果没有任何值与变量的值匹配，执行这里的代码
break;
}

循环

while

while(循环条件){//小括号中的条件结果为boolean值
满足循环条件时重复执行的代码
}

do ....while

do{
满足循环条件时重复执行的代码
}while(循环条件);

区别：while循环可能一次都不执行，do....while 循环至少执行一次

for循环

//表达式1为定义循环变量
//表达式2为判断循环条件
//表达式3为更新循环变量
for(表达式1;表达式2;表达式3){
循环体
}

首先执行表达式 1 ，再执行表达式 2 ，如果表达式 2 的结果为 true ，执行循环体，再执行表达式 3 ，再执行

表达式 2 判断，如果表达式 2 的结果为 false ，结束循环

循环控制变量

break和return

它俩都是可以在循环中停止循环。

break是停止循环后，继续执行循环之外的内容。

return是结束方法，不再执行return之后的内容

continue

在循环语句中，使用continue,可以停止本次循环，不在执行continue之后的循环，直接进入下一个循环。

循环嵌套使用

//鸡兔同笼 笼子里有若干鸡和兔，头一共35，腿一共94，鸡兔各几只？
for (int ji = 0; ji <= 35; ji++) {
for (int tu = 0; tu <= 35; tu++) {
if (ji + tu == 35 && 2 * ji + 4 * tu == 94) {
System.out.println("鸡：" + ji + "兔：" + tu);
}
}
}
//百元买百蛋 花够100元买够100个蛋 鸡蛋3个1元 鸭蛋1个3元 鹅蛋1个5元
for (int jd = 0; jd <= 100; jd++) {
for (int yd = 0; yd <= 100; yd++) {
for (int ed = 0; ed <= 100; ed++) {
//整数间相除为整数，这里鸡蛋的价格需要用浮点数表示
if (jd + ed + yd == 100 && 3 * yd + 5 * ed + jd / 3.0 == 100) {
System.out.println("鸡蛋：" + jd + "鸭蛋：" + yd + "鹅蛋：" + ed);
}
}
}
}

数组（一维数组）

一组类型相同的数的有序集合。

关于数组

实际在内存中是一块连续的空间。是保存数据的区域。

数组定义时需要确定大小和数据类型，不可改变。

定义数组时的变量保存的是实际内存空间的地址。

数据中保存的数据称为 元素 ，每个元素有一个唯一的位置，称为 索引 ( 下标 ) ，这个索引从 0 计数。

可以通过数组的索引给数组赋值或读取数组中某个索引上的值。

定义数组

语法：数据类型[] 数组名；或数组类型 数组名[]；

定义数组后，如果不初始化数组，数组无法使用。

int [] score;

定义数组的同时初始化

语法：数组名[]  数组名=new 数据类型[数组大小]；

int[] a=new int[30];

给数组赋值

动态赋值

通过数组名[索引]给数组中某个位置赋值

int[] list=new int[10];
list[0]=2;
list[2]=25;

静态赋值

在定义数组的同时赋值

数据类型[] 数组名 =new 数据类型[]{元素1，元素2，....}

数据类型 [] 数组名={元素1，元素2}

String[] list = new String[]{"小明","小王"}；
String[] list={"小明","小李"};

注意：

数组一旦初始化后，数组大小不能改变，其中的元素类型要统一

数组的索引范围是 [0, 数组大小 -1] ，使用时不能超出范围。在编译时无法识别是否超出数组索引，

但运行时会抛出 " 数组索引溢出 " 异常

数组一旦初始化后，如果没有赋值，默认有初始值

数组数据类型

数组数据类型	默认值
整型	0
浮点型	0.0
引用类型	null
布尔型	false
字符型	空白字符

增强for循环

战门用于遍历数组或集合元素的一种循环

格式：for(数据类型 变量名：数组名){}

String[] list = {"admin","qwe","aaa"};
//使用增强for循环遍历
for(String name : list){
System.out.println(name);
}

冒泡排序核心代码

外层循环控制比较的轮数
for(int i=1;i<=数组.length-1;i++){
//内层循环控制每轮比较的次数
for(int j=1;j<=数组.length-i;j++){
//判断是否要交换位置
if(数组[j-1] < 数组[j]){//如果不满足降序的条件(小于)则交换位置
//借助第三个变量交换数组中元素的位置
int temp = 数组[j];
数组[j]=数组[j-1];
数组[j-1]=temp;
}
}
}

数组工具类Arrays

Arrays 是 jdk 提供的用于处理数组的工具类。包含了如排序、复制、填充等方法，这些方法都是静态方法，直接通过Arrays 调用。