Java学习笔记

Java学习地址

西部开源-秦疆

强推这个，老师加了很多面试题

快捷键

快捷键	对应指令
psvm	public static void main(String[] args) { }
sout	System.out.println();
100.for	生成循环100次 for (int i = 0; i < 100; i++) { }
数组名.for	遍历数组元素；for( int i : 数组名) { } //缺点，没有下标

小知识点

System.out.println();	 //输出后换行
System.out.print();		 //输出后不换行

注释

//单行注释

/*多行注释*/

JavaDoc:文档注释 /** */
  /**
  *@Auther: canlan
  */
  

关键字

abstract	assert	boolean	break	byte
case	catch	char	class	const
continue	default	do	double	else
enum	extends	final	finally	float
for	goto	if	implements	import
instanceof	int	interface	long	native
new	package	private	protected	public
return	strictfp	short	static	super
switch	synchronized	this	throw	throws
transient	try	void	volatile	while

标识符

命名规则

• 所有的标识符都应该以字母（A-Z或者a-z），美元符（$）、或者下划线（__）开始
• 首字符之后可以是字母（A-Z或者a-z），美元符（$）、下划线（__）或数字的任何字符组合
• 不能使用关键字作为变量名或方法名。
• 标识符是大小写敏感的
• 合法标识符举例：age、$salary、value.、1 value
• 非法标识符举例：123abc、-salary.、#abc
• 可以使用中文命名，但是一般不建议这样去使用，也不建议使用拼音，很LoW

数据类型

• 强类型语言

  • 要求变量的使用要严格符合规定，所有变量都必须先定义后才能使用

• 弱类型语言

  • 不要求变量的使用要严格符合规定，所有变量都不需要先定义后才能使用

• Java数据类型分为两大类

  • 基本类型 (primitive type)
  • 引用类型 (reference type)

注意long类型数字后面要加L

注意float类型要在数字后面加F,double类型不用

long nu=10L;
float ff=3.12F;
//字符
char cc="A";
//字符串
String ss="nihao";
//boolean值
boolean bb=true;

字节

• 位（bit）：是计算机内部数据储存的最小单位，11001100是一个八位二进制数。

• 字节（byte）：是计算机中数据处理的基本单位，习惯上用大写B来表示，

• 1B（byte，字节）=8bit（位）

• 字符：是指计算机中使用的字母、数字、字和符号

• 1bit表示1位，

• 1Byte表示一个字节1B=8b。

• 1024B=1KB

• 1024KB=1M

• 1024M=1G

整数拓展类型

int i=10;//十进制10 输出10
int i=010;//八进制10 输出8
int i=0x10;//十六进制10 输出16	0～9 A～F

注意：

1. 银行业务表示不用float 用BigDecimal数学工具类
2. 2.强制转换 (int)+名
3. \t 表示制表符

字符拓展类型

char aa='\u0061';
System.out.println((aa);//输出a （Unicode编码）
char bb='a';
System.out.println((int)bb); //输出61                   

类型转换

由低到高自动转换，由高到低强制转换 方法:（类型）变量名

低---------------------------------->高
byte,short,char---->int---->long---->float---->double//小数高于整数

注意：

1. 不能对boolean值进行转换
2. 存在精度缺失问题

public class lesson1 {
    public static void main(String[] args) {
        System.out.println((int)12.7);//out 12
        System.out.println((int)-13.245F);//out -13
    }
}

3. JDK7新特性，数字之间可以用下划线分割

public class lesson1 {
    public static void main(String[] args) {
        int money=10_0000_0000;
        System.out.println(money);//out 1000000000
    }
}

public class lesson1 {
    public static void main(String[] args) {
        int a=128;
        byte b= (byte)a;
        System.out.println(a);//int最大是127
        System.out.println(b);//数据溢出 out -128
    }
}

//重点
public class lesson1 {
    public static void main(String[] args) {
        int money=10_0000_0000;
        System.out.println(money);//out 1000000000
        int year=20;
        long total=(long)(money)*year;//数据溢出，得先将一个数据转化成long类型，不能(long)(money*year)
        System.out.println(total);
    } 
}

变量

public class Lesson1 {
    //属性：变量
    //实例变量：从属于对象；如果不自行初始化，这个类型的默认值0
    //String默认值为Null
    //boolean默认值为false
    //除了基本类型，其余的都为Null
    String name;
    int age;
  	static double salary=25000;
  	double static salary=25000;//两个一样
		//加static变全局变量  
  	static int a=03;
    //main方法
    public static void main(String[] args) {
        //局部变量；必须声明和初始化值
        int money=10_0000_0000;
        System.out.println(money);//out 1000000000
        System.out.println(salary);
        //变量类型 变量名字 = new Lesson1()
        Lesson1 lesson1 = new Lesson1();
      	System.out.println(lesson1.age);

    }
    //其他方法

    public void add() {
    }
}

注意:

1. 如果实例变量没有用static声明，引用则需要用变量类型 变量名字 = new Lesson1()
2. 修饰符不区分先后顺序（像是static和double）

常量

final 常量名=值；//常量名一般用大写字母表示
final double PI=3.14;

变量的命名规范

• 所有变量、方法、类名：见名知意
• 类成员变量：首字母小写和驼峰原则：monthSalary
• 局部变量：首字母小写和驼峰原则
• 常量：大写字母和下划线：MAX_VALUE
• 类名：首字母大写和驼峰原则：Man，GoodMan
• 方法名：首字母小写和驼峰原则：run()，runRun()

运算符

• 括号（）优先级最高

• 算术运算符：+，-，*，/，%，++，----

• 赋值运算符：=

• 关系运算符：>，<，>=，<=，==，!=instanceof

• 逻辑运算符：&&, ||，！

• 位运算符：&，| ，^，~，>>，<<，>>>（了解！！！）

• 条件运算符 ？：

• 扩展赋值运算符：+=，-=，*=，/=

public class Lesson1 {
    public static void main(String[] args) {
        //关系运算符返回的结果：正确，错误  布尔值
      	//%取余
      	//自增自减满足C语言语法 a++，++a
        int a=10;
        int b=21;
        System.out.println(a>b);//output false
      	System.out.println(b%a);//output 1
    }
}

public class Lesson1 {
    public static void main(String[] args) {
				1onga=123123123123123L;
				int b=123;
				short c=10;
				byte d 8;
				System.out.println(a+b+c);//Long
				System.out.printin(b+c+d);//Int
				System.out.printin(c+d);//Int ==important== output 0 because 0.5int-->0
      	System.out.printin((double)c+d);//douible output 0.5
    }
}

public class Lesson1 {
    public static void main(String[] args) {
        //与（and）或（or）非（取反）
				boolean a true;
				boolean b=false;
				System.out.println（"a&&b："+（b&&a））；//逻辑与运算：两个变量都为真，结果才为true
				System.out.println（"alb："+（alb））；//逻辑或运算：两个变量有一个为真，则结果才为true
				System.out.println（"！（a&&b）："+！（a&&b））；//如果是真，则变为假，如果是假则变为真
				//短路运算
				int c=5;
				boo1eand=(c<4)&&(c++<4);//c<4为false 则不看&&后面的
				System.out.println(d);
				System.out.printin(c);
    }
}

public class Demo06{
	public static void main(String[]args){
    /*
    A=	00111100
    B=	00001101
    -----------------------------
    A&B=00001100
    A|B=00111101
    A^B=00110001  
    ~B= 11110010
    -----------------------------
    2*8=16 --->	2*2*2*2
    <<	*2 移位运算更快,效率极高！
    >>  /2
    00000000  0
    00000001  1
    00000010  2
    00000011  3
    00000100  4
    00001000  8
    00010000  16
    */
	}
}

public class Demo07{
	public static void main(String[]args){
		int a=10;
		int b=20;
		a+=b;//a a+b
		a-=b;//a a-b
    System.out.println(a);
    //字符串连接符+，String  important
		System.out.println(""+a+b);//output 1020
		System.out.println(a+b+"");//output 30
	}
}

//三元运算符
public class Demo08{
	public static void main(String[]args)
    //x ? y:z  
    //如果x==true，则结果为y，否则结果为z
    int score 80;
    String type=score<60？"不及格"："及格"；//必须掌握
    System.out.println(type); //output 及格
	}
}

包机制

• 为了更好地组织类，Java提供了包机制，用于区别类名的命名空间。
• 包语句的语法格式为：

package pkg1[.pkg2[.pkg3...]];

• 一般利用公司域名倒置作为包名；wiww.baidu.com ---------> com.baidu.www
• 为了能够使用某一个包的成员，我们需要在Java程序中明确导入该包。使用"import”语句可
  完成此功能

import package1[package2...].(classname *)

注意不要让包的名字重复，import必须在package下面

import com.kuang.base.* 
//表示全引用base中的数据

JavaDoc

• javadoci命令是用来生成自己API文档的
  • 参数信息
  • @author作者名
  • @version版本号
  • @since指明需要最早使用的jdk版本
  • @param参数名
  • @return返回值情况
  • @throws异常抛出情况

使用cd 跳转到指定文件夹
javadoc -encoding UTF-8 -charset UTF-8 (文件名).java

---

Java流程控制

Scanner对象

• 之前我们学的基本语法中我们并没有实现程序和人的交互，但是Java给我们提供了这样一个工具类，我们可以获取用户的输入。java.util.Scanner是Java的新特征，我们可以通过Scanner类来获取用户的输入。

• 基本语法：

  Scanner s new Scanner(System.in);
  

• 通过Scanner类的next() 与nextLine() 方法获取输入的字符串，在读取前我们一般需要使用hasNext() 与hasNextLine() 判断是否还有输入的数据。

package com.kuang.scanner;

import java.util.Scanner;

public class Demon1{
    public static void main(String[]args){
        //创建一个扫描器对象，用于接收键盘数据
        Scanner scanner = new Scanner(System.in);
        System.out.println("使用next方式接收：");
        //判断用户有没有输入字符串
        if (scanner.hasNext()){
            //使用next方式接收
            String str = scanner.next();
          	//String str = scanner.nextLine();
            System.out.println("输出的内容为："+str);
        }
        //凡是属于流的类如果不关闭会一直占用资源.要养成好习惯用完就关掉
        scanner.close();
    }
    
}

• next():
  • 一定要读取到有效字符后才可以结束输入。
  • 对输入有效字符之前遇到的空白，next0方法会自动将其去掉。
  • 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
  • next0不能得到带有空格的字符串。
• nextLine():
  • 以Enter为结束符，也就是说nextLine（方法返回的是输入回车之前的所有字符。
  • 可以获得空白。

if (scanner.hasNextInt()){
  i = scanner.nextInt;
    System.out.println（"小数数据："+i）；
  }else{
  System.out.println（"输入的不是小数数据！"）；
	}

scanner.hasNextInt()//判断是不是整数
scanner.hasNextFloat()//判断是不是小数
  

if选择结构

• 单选择结构

if (/*布尔表达式*/){
  //如果布尔表达式为true将执行此语句
}

• 双选择结构

if (/*布尔表达式*/){
  //如果布尔表达式为true将执行此语句
}else{
  //如果布尔表达式为false将执行此语句
}

• 多选择结构

if (/*布尔表达式1*/){
  //如果布尔表达式1为true将执行此语句
}else if(/*布尔表达式2*/){
  //如果布尔表达式2为true将执行此语句
}else if(/*布尔表达式3*/){
  //如果布尔表达式3为true将执行此语句
}else{
  //如果以上布尔表达式为false将执行此语句
}

• 嵌套结构

if (/*布尔表达式1*/){
  //如果布尔表达式1为true将执行此语句
  if(/*布尔表达式2*/){
  //如果布尔表达式2为true将执行此语
  }
}

switch多选择结构

• switch语句中的变量类型可以是：
  • byte、short.int或者char。
  • 从Java SE 7 开始
  • switch支持字符串String类型了
  • 同时case标签必须为字符串常量或字面量。

switch(expression){
  case value :
    //语句
    break;//可选
  case value :
    //语句
    break;//可选
 	//你可以有任意数量的case语句
  default ://可选
    //语句
}

package com.kuang.scanner;

public class Demon5 {
    public static void main(String[] args) {
        //case 穿透，不加break则将本case后面的选项都运行
        char grade = 'B';
        switch (grade) {
            case 'A' :
                System.out.println("优秀");
                break;
            case 'B' :
                System.out.println("良好");
            case 'C' :
                System.out.println("及格");
            default:
                System.out.println("未知等级");
        }
    }
}

//output 
//良好
//及格

while循环

while(/*布尔表达式*/){
  //循环内容
}

• 只要布尔表达式为true，循环就会一直执行下去。
• 我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环。
• 少部分情况需要循环一直执行，比如服务器的请求响应监听等。
• 循环条件一直为tue就会造成无限循环死循环】，我们正常的业务编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死奔溃！

do…while循环

• 对于while语句而言，如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件，也至少执行一次。
• do…while循环和while循环相似，不同的是，do.….while循环至少会执行一次。
• While和do-While的区别：
  • while先判断后执行。dowhile是先执行后判断！
  • Do.…while总是保证循环体会被至少执行一次！这是他们的主要差别。

do{
  //代码语句
}while(布尔表达式)；

for循环

• 虽然所有循环结构都可以用while或者do.while表示，但Java提供了另一种语句 for循环，使一些循环结构变得更加简单。
• for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。
• for循环执行的次数是在执行前就确定的。语法格式如下：

for(初始化;布尔表达式;更新){
  //代码语句
}
例如：
for (int i=1;i<=100;i++){
  
}

• 关于for循环有以下几点说明：
  • 最先执行初始化步骤。可以声明一种类型，但可初始化一个或多个循环控制变量，也可以是空语句。
  • 然后，检测布尔表达式的值。如果为true，循环体被执行。如果为false，循环终止，开始执行循环体后面的语句。
  • 执行一次循环后，更新循环控制变量（迭代因子控制循环变量的增减）。
  • 再次检测布尔表达式。循环执行上面的过程。

//一种死循环的写法
for(;;){
  
}

增强for循环

• 这里我们先只是见一面，做个了解，之后数组我们重点使用
• Java5引入了一种主要用于数组或集合的增强型for循环。
• Java增强for循环语法格式如下：

for(声明语句:表达式){
  //代码句子
}

• 声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循
• 环语句块，其值与此时数组元素的值相等。
• 表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

package com.kuang.scanner;

public class Demon6 {
    public static void main(String[] args) {
        int[] numbers = {
            10,20,30,40,50
        };
        for (int i = 0; i < 5; i++) {
            System.out.println(numbers[i]);
        }
        System.out.println("=================");//两种方法对比
        //遍历数组元素
        for(int x:numbers){
            System.out.println(x);
        }
    }
}

Java方法

• System.out.printIn()，那么它是什么呢？
• Java方法是语句的集合，它们在一起执行一个功能。
  • 方法是解决一类问题的步骤的有序组合
  • 方法包含于类或对象中
  • 方法在程序中被创建，在其他地方被引用
• 设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只完成1个功能，这样利于我们后期的扩展。

package com.kuang.method;

public class Demon1 {
    //main方法，机器完成，一般用户定义的在main方法外面
    public static void main(String[] args) {
      //实际参数：实际调用传递给他的参数  
      int sum = add( 1, 2 );
      System.out.println(sum);

    }
    //用户定义方法
    //加法
  	//形式参数，用来定义作用的
    public static int add(int a,int b ){
        return a+b;
    }

}

方法的重载

• 重载就是在一个类中，有相同的函数名称，但形参不同的函数
• 方法的重载的规则：
  • 方法名称必须相同。
  • 参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。
  • 方法的返回类型可以相同也可以不相同。
  • 仅仅返回类型不同不足以成为方法的重载。
• 实现理论：
  • 方法名称相同时，编译器会根据调用方法的参数个数、参数类型等去逐个匹配，以选择对应的方法，如果匹配失败，则编译器报错。

可变参数

• JDK1.5开始，Java支持传递同类型的可变参数给一个方法。
• 在方法声明中，在指定参数类型后加一个省略号（…）。
• 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

package com.kuang.method;

public class Demon2 {
    public static void main(String[] args) {

    }

    public static void printMax(double...numbers) {
        if (numbers.length == 0) {
            System.out.println("No argument passed");
            return;
        }
        double result = numbers[0];
        //排序！
        for (int i = 1; i < numbers.length;i++) {
            if (numbers[i] > result) {
                result = numbers[i];
            }
        }
        System.out.println("The max value is"+ result);
    }
}

数组

• 构建数组
  • 首先必须声明数组变量，才能在程序中使用数组。下面是声明数组变量的语法：

dataType[] arrayRefVar;//首选的方法
或
dataType arrayRefVar[];//效果相同，但不是首选方法

• Java语言使用new操作符来创建数组，语法如下：

dataType[] arrayRefVar = new dataType[arraySize];

• 数组的元素是通过索引访问的，数组索引从0开始。

• 获取数组长度：arrays.length

//例子
package com.kuang.array;

public class Demon1 {
    public static void main(String[] args) {
        //变量的类型 变量的名字 = 变量的值；
        //数组类型
        int nums[];//定义array，未赋值，这个方法是早期Java为了方便C/C++程序员使用Java
        int[] numsm;//1.定义array，未赋值
        numsm = new int[10];//2.创建一个数组。这里面可以存放1e个int类型的数才
      	int[] nums2 = new int[10];//直接定义并确定大小
        //3.给数组元素中赋值
        nums[0]=1;
        nums[1]=2;
        nums[2]=3;
        nums[3]=4;
        nums[4]=5;
        nums[5]=6;
        nums[6]=7;
        nums[7]=8;
        nums[8]=9;
        nums[9]=10;
    }
}

内存分析

package com.kuang.array;

public class Demon2 {
    public static void main(String[] args) {
        //静态初始化：创建 + 赋值
        int[] a = {
            1,2,3,4,5,6,7,8
        };
        System.out.println(a[0]);
        
        //动态初始化 ：包含默认初始化(未赋值的默认为0)
        int[] b = new int[10];
        b[0] = 10;
        System.out.println(b[0]);
    }
}

        for (int i : a) {
            
        }

数组的四个基本特点

• 其长度是确定的。数组一旦被创建，它的大小就是不可以改变的。
• 其元素必须是相同类型，不允许出现混合类型。
• 数组中的元素可以是任何数据类型，包括基本类型和引用类型。
• 数组变量属引引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。数组本身就是对象，Java中对象是在堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

多维数组

• 多维数组可以看成是数组的数组，（比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
• 二维数组

int[][] a = new int[2][5];//构建两行五列的二维数组

package com.kuang.array;

public class Demon3 {
    public static void main(String[] args) {
        int[][] array = {
                {1, 2}, {3, 4}, {5, 6}, {7, 8}
        };
        System.out.println(array[2][0]);//output 5
    }
}

二维数组结构

Arrays类

• 数组的工具类java.util.Arrays
• 由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。
• 查看JDK帮助文档
• Arrays类中的方法都是static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而"不用"使用对象来调用（注意：是不用”而不是“不能"）
• 具有以下常用功能：
  • 给数组赋值：通过 fill 方法。
  • 对数组排序：通过 sort 方法，按升序。
  • 比较数组：通过 equals 方法比较数组中元素值是否相等。
  • 查找数组元素：通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

package com.kuang.array;
import java.util.Arrays;
public class Demon4 {
    public static void main(String[] args) {
        int[] a = {
            1,2,3,4,9090,31231,543,21,3,23
        };
        //System.out.println(a);/[I@4554617c
        //打印数组元素Arrays.toString
        //System.out.println(Arrays.toString(a));
        Arrays.sort(a);//数组进行排序
        System.out.println(Arrays.toString(a));
    }
}