数据类型：
java的数据类型分为两大类：基本类型和引用类型
基本类型：
整数类型：
byte 一个字节 -128-127
short 2个字节 32768-32767
int 4个字节 很大
long 8个字节 巨大 用long的时候赋值要在数字后加 L
扩展：
public class HelloWorld {
public static void main(String[] args) {
int i=10; //10进制
int i2=010; //八进制 八进制0开头
int i3=0x10; //十六进制 十六进制0x开头
int i4=10_00001_23; //JDK7新特性，数字之间可以用下划线分割，且输出的时候不会被输出
}
}
浮点类型：
float 4个字节 用float的时候赋值要在数字后面加 F
double 8个字节
扩展：最后完全避免使用浮点数进行比较
字符类型：
char 2个字节 只能发一个字符
String 定义字符串 不是关键字来的，是类
扩展：所有的字符本质还是数字即ASCII编码
转义字符：
\t 多几个空格
\n 换行
....
boolean类型：
boolean xx= true
其值只有true和false两个
引用类型： 类、接口、数组
类型转换：
数字范围级别：低--------------------------------------------->高
byte,short,char --->int --->long--->float--->double
当高级别向低级别转换时，需要强制类型转换；低级别向高级别转换时，无需任何操作
数据类型按精度（容量）大小排序：
自动类型转换：
精度小的类型自动转为精度大的数据类型，这就是自动类型转换
自动类型转换细节：
有多种类型的数据混合运算时，系统首先自动将所有数据转换成容量最大那种数据类型，然后再计算
当把精度（容量）大的数据类型赋值给精度（容量）小的数据类型，会报错；反正会进行自动类型转换
(byte、short)和char之间不会相互自动转换
byte、short、char 它们三者可以计算，在计算时首先转换为int类型
boolean不参与转换
表达式结果的类型自动提升为操作数中最大的类型
强制类型转换：
强制转换： （类型）变量名
注意：
不能对布尔值进行转换
不能把对象类型转换为不相干类型
在把高容量转换到低容量时，需要强制类型转换。此时会出现内存溢出或者精度问题
不同类型的数字相结合成为一个新的数字时，得出的结果按最高的级别来算，最低只能是int
public class HelloWorld {
public static void main(String[] args) {
int i=10_0000_0000;
int b=20;
long sum=i*b; //结果是负数，原因是i*b之后还是int类型，然后溢出了
long sum1=i*((long)b); //结果是正数，先把一个数转化为long 结果i*b之后就算long
System.out.println(sum);
}
}
变量与常量：
变量分为类变量、实例变量、局部变量
public class HelloWorld {
//类变量 static
static double salary= 2000;
//实例变量:从属于对象；若不进行初始化，则为默认值，整数0 浮点数0.0 布尔值false 除了基本类型其余都是NULL
int a;
//main方法
public static void main(String[] args) {
//局部变量：必须声明且初始化，有效范围只在方法內
int i=10; //局部
//变量类型 变量名字 = 值 使用实例变量必须new
HelloWorld text = new HelloWorld();
System.out.println(text.a);
//类变量 static 类变量可以直接用
System.out.println(salary);
}
//其他方法
public void add(){
}
}
常量：
格式：final 常量名 =值; 常量名一般用大写字符
public class HelloWorld {
//修饰符，不存在先后顺序，所以可以改为final static
static final double PI=3.14;
public static void main(String[] args) {
System.out.println(PI);
}
}
变量的命名规范：
类成员变量：首字母小写和驼峰原则（除了第一个单词外，后面的单词首字母大写）myName
局部变量：首字母小写和驼峰原则
常量：大写字母和下划线：MAX_VALUE
类名：首字母大写和驼峰原则：MyName
方法名：首字母小写和驼峰原则：myName()
运算符：
数字范围级别：低--------------------------------------------->高
byte,short,char --->int --->long--->float--->double
不同类型的数字相结合成为一个新的数字时，得出的结果按最高的级别来算，最低只能是int
关系运算符：返回值是true或false
public class HelloWorld {
public static void main(String[] args) {
int a=10;
int b=20;
//字符串连接符 + 当出现字符串时，会把字符串后的内容转化为字符串，并进行连接
System.out.println(""+a+b); //结果1020
System.out.println(a+b+""); //结果30
}
}
Scanner对象：
可以通过Scanner类获取用户的输入
Scanner的用法：
导包：import java.util.Scanner; （IDEA上new一下就自动导包了）
新建对象：Scanner s new Scanner(System.in); s是变量名，其他都不能改
使用对象：
s.next(); 输入字符串，遇到空格结束 s.nextLine() 输入字符串，遇到回车结束
s.nextInt(); 输入整数
s.nextFloat(); 输入浮点数float类型
s.nextDouble(); 输入浮点数double类型
在一个方法中new了一个scanner对象后，可以给不同的类型进行输入赋值
通过Scanner类的next()与nextLine()方法获取输入的内容，一般读取前需要使用hasNext()与hasNextLine()来判断是否含有相同类型的输入的数据。如hasNextInt() 判断输入的是否是整数
import java.util.Scanner;
//hasNext()的用法
public class doc {
//输入多个数字，算总和和平均数。通过输入非数字来结束
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
double sum=0;
int m=0;
while(scanner.hasNextDouble()){ //当我输入到x时 x不是double类型 循环结束
double x=scanner.nextDouble();
m++;
sum+=x;
}
System.out.println("和为："+sum);
System.out.println("平均值："+(sum/m));
}
}
next()与nextLine()的区别：
next()遇到空格就作为分隔符或结束符
nextLine()以Enter作为结束符 可以获得空白
import java.util.Scanner;
public class doc {
public static void main(String[] args) {
Scanner s =new Scanner(System.in);
System.out.println("使用next方式接收");
//判断用户有没有输入字符串
if(s.hasNext()){ //先判断用户输入的是什么内容
//使用next接收
String str=s.next();
System.out.println("输入的内容："+str); //输入Hello World 结果为Hello
}
//用完scanner最好关闭
s.close();
}
}
import java.util.Scanner;
public class doc {
public static void main(String[] args) {
Scanner s=new Scanner(System.in);
System.out.println("用nextline方式接收");
if(s.hasNextLine()){ //先判断用户输入的是什么内容
//使用nextLine接收
String str=s.nextLine();
System.out.println("输入的内容为："+str); //输入Hello World 结果为Hello World
}
s.close();
}
}
选择结构：
单选择结构：
if(布尔表达式){ //true就执行
}
import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
Scanner s=new Scanner(System.in);
String a=s.nextLine();
//equals 字符串比较
if(a.equals("Hello"))
System.out.println(a);
s.close();
}
}
双选择结构：
if(布尔表达式){ //ture 就执行
}else{ //false就执行
}
import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
Scanner s=new Scanner(System.in);
System.out.println("输入成绩：");
int score=s.nextInt();
if(score>60){
System.out.println("及格");
}else{
System.out.println("不及格");
}
s.close();
}
}
多选择结构：
if(布尔表达式1){ //true就执行
}else if(布尔表达式2){ //true就执行
}else if(布尔表达式3){ //true就执行
}else{ //上面3个表达式都false就执行
}
import java.util.Scanner;
public class Demo {
public static void main(String[] args) {
Scanner s=new Scanner(System.in);
int score=s.nextInt();
if(score==100){
System.out.println("满分");
}else if(score<100&&score>=90){
System.out.println("A");
}else if(score<90&&score>=80){
System.out.println("B");
}else{
System.out.println("C");
}
s.close();
}
}
switch多选择结构：
switch(表达式){
case 常量：语句；break；
case 常量：语句；break;
case 常量：语句；break;
default: 语句；break;
}
JDK7的新特性，表达式的结果可以是字符串！
public class Demo {
public static void main(String[] args) {
char grade='C';
switch (grade){
case 'A':
System.out.println("A");
break; //若不写break，会发生case穿透
case 'B': //这个case无break，若执行了，还会穿透到下面的case C
System.out.println("B");
case 'C':
System.out.println("C");
default:
System.out.println("aaaa");
}
}
}
循环结构：
while循环：
while(布尔表达式){
//内容
}
do....while循环：
do{
}while(布尔表达式);
do....while() 至少执行一次
for循环：
for(初始化；布尔表达式；更新){ //初始化不能只写一个变量，必须带上赋值
}
输入循环次数加上 .for 回车自动生成for循环
public class Demo {
public static void main(String[] args) {
int a=1;
int sum=0;
for(a=1;a<=100;a++){ //写成for(a;a<=100;a++) 就报错
sum+=a;
}
System.out.println(sum);
}
}
练练手：
public class Demo {
public static void main(String[] args) {
//输出1-1000之间能被5整除的数，每行输出3个
for (int i = 1; i <= 1000; i++) {
if(i%5==0){
System.out.print(i+"\t"); //print输出后不换行，println输出自带换行
}
if(i%(5*3)==0){ //每行输出3个
System.out.println(); //换行
//System.out.print("\n"); 换行
}
}
}
}
增强for循环：
增强for循环主要用于数组或集合的循环
for(声明语句 ：表达式){
//代码句子
}
public class Demo {
public static void main(String[] args) {
int[] numbers={10,20,30,40,50}; //定义数组
//遍历数组的元素
for (int x:numbers){ //numbers数组的每一项遍历出来赋值给了x
System.out.println(x);
}
System.out.println("==============");
//等同于上面的代码
for(int i=0;i<5;i++){
System.out.println(numbers[i]);
}
}
}
break与continue：
break：用于结束循环,不执行了
continue：用于结束这一次循环，进行下一次循环
数组：
一维数组的介绍
数组是相同类型的数据的有序集合，每一个数据成为一个数组元素，每一个数组元素可以通过一个下标来访问
数组是引用类型。它的元素相当于类的实例变量
特点：
数组的长度是固定的。一旦被创建，大小不可以改变
其元素必须是相同类型
数组中的元素可以是任何类型数据，包括基本类型和引用类型
数据变量是引用类型，数组也可用看成是对象，数组中的每个元素相当于该对象的成员变量
数组本身是对象，数组对象本身是在堆中的
数组的声明创建：
先声明数组变量，然后通过new来创建数组，数字的下标从0开始
public class Demo01 {
public static void main(String[] args) {
//变量类型 变量名字 = 变量的值;
int[] nums1; //声明了一个数组，首选，但是还没分配空间; 可写成int nums2[]; 不推荐
nums1 = new int[10]; //分配空间，创建一个可以放10个int类型数据的数组
int[] nums2=new int[10]; //这一行把定义和new结合，等同于上面2行
nums2[0] = 1; //给数组第0个数组赋值
}
}
数组的声明：
public class Demo02 {
public static void main(String[] args) {
//静态初始化：创建+赋值 不用写new,但是初始化有多少个值，就是数组的长度
int[] a={1,2,3,4,5,6,7,8};
//动态初始化： 创建后，数组元素默认都为0
int[] b=new int[10];
}
}
数组的赋值和遍历：
获取数组的长度用arrays.length （arrays数组变量名）
public class Demo01 {
public static void main(String[] args) {
int[] num=new int[10];
for (int i = 0; i < 10; i++) {
num[i]=i;
}
//遍历输出数组
for (int i = 0; i < num.length; i++) { //num.length 是数组的长度
System.out.print(num[i]+" ");
}
System.out.println();
//增强型for输出数组 没有下标
for (int array : arrays) { //输入数组名.for 快速生成
System.out.println(array);
}
}
}
数组作为方法的参数
public class Demo04 {
public static void main(String[] args) {
int[] arrays={1,2,3,4,5};
printArrays(arrays); //数组作为参数
}
//打印数组 数组作为方法的参数
public static void printArrays(int[] arrays){
for (int i = 0; i < arrays.length; i++) {
System.out.print(arrays[i]+" ");
}
}
}
=数组作为返回值
public class Demo04 {
public static void main(String[] args) {
int[] arrays={1,2,3,4,5};
int[] reverse = reverse(arrays);
}
//反转数组 数组作为返回值
public static int[] reverse(int[] arrays){ //定义的方法类型必须也是数组
int[] result =new int[arrays.length];
for(int i=0,j= result.length-1;i< arrays.length;i++,j--){
result[j]=arrays[i];
}
return result; //返回一个数组
}
}
二维数组的介绍
二维数组就是一个数组中存放了其他数组
当初始化一个二维数组时，若某行某列没有赋值，则默认不存在，遍历的时候并不会输出
public class Demo05 {
public static void main(String[] args) {
//定义了一个array[4][2]
int[][] array={{1,2},{2,3},{3,4},{4,5}};
System.out.println(array.length); //输出二维数组的长度是4
System.out.println(array[0].length); //输出二维数组中第一个数组的长度 结果是2
//二维数组的打印
for (int i = 0; i < array.length ; i++) {
for (int j = 0; j <array[i].length ; j++) {
System.out.print(array[i][j]+" ");
}
System.out.println();
}
}
}
二维数组的增强型for遍历：
快捷操作：array1.for 就自动生成 for (int[] ints : array1) 然后ints.for就自动生成for (int anInt : ints)
public class Demo07 {
public static void main(String[] args) {
int[][] array1 =new int[11][11]; //二维数组的定义
for (int[] ints : array1) { //相当于把array1中的每一个数组赋给了ints
for (int anInt : ints) { //把ints数组中的值赋给了anInt
System.out.print(anInt+" ");
}
System.out.println();
}
}
}
Arrays类
Arrays类包含了多种对数组进行特定操作的方法
使用的时候就 Arrays . 方法(数组名) 就可以直接使用
使用Arrays需时会自动导包 import java.util.Arrays;
Arrays类的方法可以查看JDK帮助文档
常用的有：
toString 打印数组
sort 升序排序数组
equals 比较数组中的元素是否相等
binarySearch 对排序好的数组进行二分查找
import java.util.Arrays;
public class Demo05 {
public static void main(String[] args) {
int[] a={1,2,3,456,12,4};
Arrays.sort(a);
System.out.println(Arrays.toString(a));
}
}
