Java基础
一、基本数据类型
数据类型 | 默认值 | 数据类型 |
---|---|---|
byte | 0 | 8位,有符号,以二进制补码表示 |
short | 0 | 16位,有符号,以二进制补码表示 |
char | ‘u0000’ | 一个单一的 16 位 Unicode 字符 |
int | 0 | 32位,有符号,以二进制补码表示 |
long | 0L | 64位,有符号,以二进制补码表示 |
float | 0.0f | 32位,单精度 |
double | 0.0d | 64位,双精度 |
⭐小数的优先级一定大于整数
自动类型转换
符合规律:转换前的数据类型位数必须低于转换后的数据类型
例如:16位的可以自动转换为32位的数据类型
public class conversion {
public static void main(String[] args) {
short a = 7;
int b = a;
System.out.println("short自动转换为int类型的结果为:"+b);
}
}
运行结果:
强制类型转换
- 条件是转换的数据类型必须是兼容的。
- 格式:(类型)变量名
- 强制转换会造成内存溢出或者是精度问题
public class conversion {
public static void main(String[] args) {
double a = 4578;
int b = (int) a;
System.out.println("double数据类型强制转换为int类型,结果为:"+b);
}
}
运行结果:
注意点:
- 不能使用布尔值(boolean)进行数据转换
- 不能把对象类型转换为不相干的类型
- 数字之间可以使用下划线进行分割
二、变量、常量、作用域
变量:所有变量在使用前必须声明
int a = 1;
type b = 2;
a,b都是变量
变量作用域
局部变量:必须声明和初始化,并且只能在局部中调用
实例变量:需要先定义变量再new,从属于对象。
public class Variable {
// 这个实例变量对子类可见
public String name;
// 私有变量,仅在该类可见
private double salary;
//在构造器中对name赋值
public Variable (String empName){
name = empName;
}
//设定salary的值
public void setSalary(double empSal){
salary = empSal;
}
// 打印信息
public void printEmp(){
System.out.println("名字 : " + name );
System.out.println("薪水 : " + salary);
}
public static void main(String[] args){
Variable variable = new Variable("RUNOOB");
variable.setSalary(1000.0);
variable.printEmp();
}
}
类变量(静态变量):独立于方法之外,用static修饰
public class Employee {
private static int age;
public static final String NAME = "wyf";
public static void main(String[] args){
age = 21;
System.out.println(NAME+"的年龄:"+age+"岁");
}
}
运行结果:
常量:进行初始化,并且不能再改变数值
格式:final 常量名=常量值;
命名方式:使用大写字母以及下划线
三、运算符
算数运算符
+ | - | * | / | % | ++ |
---|
public static void main(String[] args){
int a = 4;
System.out.println(a);
int b = a++;//执行完这行代码后,先给b赋值,再自增
System.out.println(b);
int c = ++a;//执行完这行代码后,再自增,先给c赋值,
System.out.println(c);
}
关系运算符
== | != | > | < | >= | <= |
---|
逻辑运算符
&& | || | ! |
---|---|---|
a && b | a || b | ! (a && b) |
两个为真,true | 一个为真,true | 为假,则为true |
其他运算
幂运算
double pow = Math.pow(3, 1);
System.out.println(pow);
短路运算
int d = 5;
boolean x =(c<4) && (c++<4);
System.out.println(x);
System.out.println(d);
解释:当c<4为false时不会走c++<4,直接返回false,并且不会进行自增。
字符串连接符:空字串 “”
三元运算符
//x ? y : z
//如果x==true,则结果为y,否则为z
int score = 50;
String type =score <80 ? "不及格":"及格";
System.out.println(type);
int max =a>b? a:b;
max =max>c?max:c;
System.out.println(max);
★ 运算符的优先级——括号
Java Doc
四、Scanner使用
获取输入的字符串:next()
与nextLine()
方法
Scanner scanner = new Scanner(System.in);
String str = scanner.next();
System.out.println(str);
scanner.close();
判断是否还有输入的数据:hasNext()
与hasNextLine()
-
next()不能得到带有空格的字符串
Scanner scanner = new Scanner(System.in); int a = 0; float b =0.0f; System.out.println("请输入整数:"); if (scanner.hasNextInt()){ a = scanner.nextInt(); System.out.println("您输入的整数为:"+a); System.out.println("请输入小数:"); if (scanner.hasNextFloat()){ b = scanner.nextFloat(); System.out.println("您输入的小数为:"+b); } else{ System.out.println("请输入小数!"); } } else{ System.out.println("请输入整数!"); } scanner.close();
五、选择结构
equals:判断字符串是否相等,尽量减少==号进行字符串的比较
if语句当中至多一个else语句,在所有else if语句之后
⭐获取邮箱@前面的字符串
int index = email.indexOf("@");
if (index == -1){
return "邮箱格式错误!";
}
return email.substring(0,index);
switch多选择结构
**switch:匹配一个具体的值 ,case穿透:没有加break**
⭐获取手机号的尾数:
//3.2获取手机号的尾数
char c = tel.charAt(10);
//3.2定义用来保存最终结果的变量price,初始值为0
int price = 0;
//3.3根据c字符的值,来为price重新赋值
switch(c) {
case '8': price=50; break;//尾数为8支付50
case '4': price=0; break;//尾数为4免费
default: price=20;//其他情况需支付20
}
六、循环结构
while循环
while(布尔表达式){
//循环内容
}
- 布尔表达式为true,程序会陷入死循环
- 1+2+3+…+100=?
- 不满足条件则不能进入循环
int i = 0;
int sum = 0;
while(i<=100){
sum = sum + i;
i++;
}
System.out.println(sum);
do…while循环
-
至少循环一次
int i = 0; int sum = 0; do { sum = sum + i; i++; }while (i<=100); System.out.println(sum);
while与do…while的区别:
-
while先判断后执行,do…while是先执行后判断
-
do…while总是保证循环体会被至少执行一次!
int a = 0; while (a<0){ System.out.println(a); a++; } System.out.println("=========================="); do { System.out.println(a); a++; }while (a<0);
输入结果:
for循环
结构体:
-
for(初始化;布尔值;迭代){
//代码语句
} -
for(声明语句:表达式){
//代码语句
}
for (int i = 0; i < 1000; i++) {
int a =0 ;
if (i % 5 == 0){
System.out.print(i+"\t");//+"\t"可以实现i与i之间有空格
}
if (i%(5*3)==0){
System.out.println();//每三个换一行
}
使用for循环实现九九乘法表
for (int j = 1; j <= 9; j++) {
for (int i = 1; i <=j; i++) {
System.out.print(j+"*"+i+"="+j*i +"\t");
}
System.out.println();
}
- 打印第一列
- 固定的1再使用循环包起来
- 去掉重复项,i<=j
- 调整样式
七、方法
执行功能:方法包含与类或对象当中
解决一类问题的有序组合
在程序中被调用,在其他地方引用
命名规则:小写字母开头驼峰命名
设计原则:原子性,即一个方法只完成1个功能,利于后期的扩展
方法类似于函数,包含一个方法头和方法
-
修饰符:可选,
-
返回值类型:void或其他返回值
-
方法名:实际名称,小写字母开头,驼峰结构
-
参数类型:占位符,可选,可以不包含任何参数
-
形式参数:用来定义作用的,a跟b就是形式参数
public static int add(int a,int b)
-
实际参数:实际调用传递的参数,1跟2是实际参数
int sum =add(1.2)
-
-
方法体:具体语句,定义该方法的功能
return可以是返回也可以中止方法
方法的重载
规则:方法名称必须相同
参数列表必须不同(个数不同、类型不同、参数排序顺序不同等)
返回类型可以相同也可以不相同
仅是返回类型不同不足以成为方法的重载
可变参数-不定项参数
在方法声明中,在指定参数类型加一个省略号(…),并且只能指定一个可变参数,必须位于方法参数的最后一个。
java只有值传递
args.length //数值长度
递归结构
- 头部:什么时候不调用自身方法,如果没有头,方法将陷入死循环
- 身体:什么时候需要调用自身方法
- 递归:n*f(n-1)
八、数组
基本特点
-
长度确定,不可更改,如果越界则报
ArrayIndexOutofBounds
-
相同类型的有序集合,不允许混合类型,每个数据元素通过下标访问,下标从0开始
-
元素可以是任何数据类型,包括基本类型和引用类型
-
数组变量属于引用类型,数组也可以看成是对象,元素相当于成员变量
-
数组对象本身是在堆当中的
-
获取数组长度:
arrays.length
数组的使用
For-Each 循环
总和:
for (int i = 0; i < ints.length ; i++) {
sum=sum+ints[i];
}
System.out.println(sum);
遍历:
for (int i = 0; i < ints.length ; i++) {
sum=sum+ints[i];
System.out.println(sum);
}
最大值:
for (int i = 0; i < ints.length ; i++) {
if (ints[i]>sum){
sum=ints[i];
}
}
System.out.println(sum);
}
多维数组
格式:int[][] arrays={
{12,12,12},{15,32,4}};
for (int i = 0; i <arrays.length ; i++) {
for (int j = 0; j <arrays[i].length; j++) {
System.out.println(arrays[i][j]);
}
}
数组的应用
Arrays类
常用功能:
- 给数组赋值:full
- 排序:sort,升序
- 比较:equals,比较数组元素值是否相等
- 查找:
binarySearch
对排序好的数组进行二分查找法
打印数组元素:
int[] a={
154,1,15454,3,545,6};
System.out.println(Arrays.toString(a));
升序排序:
Arrays.sort(a);
System.out.println(Arrays.toString(a));
数组填充:
Arrays.fill(a,0);
System.out.println(Arrays.toString(a));
``toString的实现:``
for (int i = 0; i <a.length ; i++) {
if (i==0){
System.out.print("[");
}if (i==a.length-1){
System.out.print(a[i]+"]");
} else{
System.out.print(a[i]+", ");
}
}
稀疏数组
冒泡排序(八种排序)
1、比较数组中,两个相邻的元素,如果第一个数比第二个数大,就交换位置。
2、每次比较都会产生出一个最大,或者是最小的数字
3、以此循环比较,时间复杂度为O(n2)
public static int[] sort(int[] arrays){
int temp=0;
for (int i = 0; i < arrays.length-1 ; i++) {
for (int j = 0; j < arrays.length-1-i ; j++) {
if (arrays[j+1] < arrays[j]){
temp=arrays[j];
arrays[j]=arrays[j+1];
arrays[j+1]=temp;
}
}
}
return arrays;
}
优化:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-r9OLcR8h-1648542594652)(C:\Users\qhqz\AppData\Roaming\Typora\typora-user-images\image-20220329162820787.png)]
九、内存与初始化
-
堆:存放new的对象和数组,可以被所有的线程共享,不会被存放别的对象引用
-
栈:存放基本变量类型,会包含基本类型的具体数值;引用对象的变量,会存放这个引用在堆里面的具体地址
-
方法区:可以被所有的线程共享,包含了所有的class和static变量
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Kku8oqqD-1648542594653)(C:\Users\qhqz\AppData\Roaming\Typora\typora-user-images\image-20220328172124550.png)]
静态初始化:创建+赋值
动态初始化:创建+给予内存空间大小,且包含默认初始化
部分内容来源:B站狂神说Java、Java | 菜鸟教程