文章目录
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
注意:
- 银行业务表示不用float 用BigDecimal数学工具类
- 2.强制转换 (int)+名
- \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//小数高于整数
注意:
- 不能对boolean值进行转换
- 存在精度缺失问题
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
}
}
- 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() {
}
}
注意:
- 如果实例变量没有用static声明,引用则需要用
变量类型 变量名字 = new Lesson1()
- 修饰符不区分先后顺序(像是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
}
}
二维数组结构
![截屏2022-01-27 17.01.39](https://tva1.sinaimg.cn/large/008i3skNly1gysc7yge0dj30ye0mign0.jpg)
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));
}
}