基础知识
Hello world
public class Main {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
注释:
1.单行注释 // 注释信息
2.多行注释 /*注释信息*/
3.文档注释 /**注释信息*/
public class HelloWorld {
// main方法,程序的主入口
public static void main(String[] args) {
// 输出语句,打印语句
// 把小括号里的内容进行输出打印
System.out.println("Hello World!");
}
}
关键字
class 用于创建一个类
字面量
- 整数类型
- 小数类型
- 字符串类型 : “NB” 双引号引起的都是字符串类型变量
- 字符类型:‘A’ ‘X’ 单引号引起的是字符类型变量,单引号内只能有单个字符
- 布尔类型:true,false
- 空类型: null 空字符不能直接打印
制表符 /t
在打印的时候,把前面的字符串补齐到 8 ,或者 8 的整数倍 。
System.out.println("name" + '\t' + "age")
System.out.println("Tom" + '\t' + "23")
System.out.println("Sam" + '\t' + "18")
变量
- 定义格式:
int a = 100
- 使用变量:输出打印,参与计算,修改记录的值
- 使用场景:重复使用某个值,存储经常改变的值
- 注意是想:变量只能存储一个值,变量名不能重复,一条语句可以定义多个变量,使用之前赋值
计算机的存储规则
文本:数字,字母,汉字
图片:分辨率,像素,三原色
声音:对声音的波形图进行采样再存储
任意数据都是以二进制的方式存储
不同进制在代码种的表现形式:
- 二进制,代码中以 0b 开头
- 十进制,默认,代码中不需要加开头
- 八进制,代码中以 0 开头
- 十六进制,代码中以 0x 开头
十进制转任意其他进制 除基取余法
数据类型
- 整数:
1. byte : 内存占用 :1 取值范围:-128 - 127
2. short :内存占用 :2
3. int : 内存占用 : 4 默认
4. long : 内存占用 :8
5. 如果要定义long类型的变量,在数值后面需要加一个L作为后缀,建议使用大写的long n = 999999999L;
2.浮点数
1.float: 4 如果要使用float类型的变量,需要在数值后面加一个F作为后缀,例如float f = 10.01F;
2.double:8 默认 - 字符:char
- 布尔类型:boolean
标识符
命名规范——硬性建议
- 由数字、字母、下划线、美元符$组成
- 不能以数字开头
- 不能是关键字
- 区分大小写
命名规范——软性建议,见名知意
- 小驼峰命名法:
- 适用于方法、变量
- 第一个单词首字母小写,其他的单词首字母大写
- 例如:‘name’ , ‘firstName’
- 大驼峰命名法:
- 适用于 类名
- 全部单词的首字母大写
- 例如: ‘FindThing’ ‘GetOffer’
键盘录入
// 导包 ,导入Scanner包
import java.util.Scanner
public class ScannerDemo{
public static void main(String[] args){
// 创建对象,表示即将使用 Scanner 类
Scanner sc = new Scanner(System.in);
// 打印提示信息
System.out.println("请输入内容")
// 接收数据 , i记录了从键盘录入的数据
int i = sc.nextInt();
// 打印数据
System.out.println(i)
}
}
运算符
算数运算符
基础知识
- 加 +
- 减 -
- 乘 *
注意:在代码中有小数参加计算,结果有可能会不精确 - 除 /
例10 / 2 = 5
10 / 3 = 3
10.0 / 3 = 3.33333335
- 取模,取余 %
例10 % 2 = 0
10 % 3 = 1
注:整数操作只能得到整数,要想得到小数,则必须要有浮点数参与计算
例:数值拆分
public class num_spilt {
public static void main(String[] args) {
//从键盘录入一个三位数,获取其个位、十位、百位
// 1.键盘录入
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个三位数");
int num = sc.nextInt();
// 2.获取个位,十位,百位
int ge = num % 10;
int shi = num /10 % 10;
int bai = num /100 % 10;
System.out.println(ge);
System.out.println(shi);
System.out.println(bai);
}
}
隐式转化和强制转化
隐式转化(自动类型提升):把一个取值范围小的数值,转化成一个取值范围大的数值
数值范围大小关系 byte < short < int < long < float < double
两种提升规则
- 取值范围小的和取值范围大的进行运算,小的会先提升为大的,然后再进行计算
- byte, short, char 三种类型的数据在运算的时候,都会先提升为 int , 然后再进行计算
强制转化 如果把一个取值范围大的数值,赋值给取值范围小的变量,是不允许直接赋值的,如果一定要转化,则必须使用强制转化方法。
格式 目标数据类型 变量名 = (目标数据类型)被强制转化的数据
例:
double a = 123;
int b = (int)a
‘+’ 的三种操作类型
数字相加
public class test2 {
public static void main(String[] args) {
// 强制类型转换
byte a = 10;
byte b = 20;
int result1 = a + b;
byte result2 = (byte)(a+b);
// 数据过大,强制转换可能会发生错误
System.out.println(result1);
System.out.println(result2);
}
字符串相加
当 ‘+’ 操作中 出现字符串时,这个 ‘+’ 就变成了字符串的连接符, 而不是算数运算符了。会将前后的数据进行拼接,并产生一个新的字符串
例如:
"123" + 123 = "123123"
连续 + 时 ,从左到右 逐个相加
1 + 99 + "个offer" = "100个offer"
1 + 2 + "abc" + 1 + 2 = "3abc12"
练习:数值拆分
public class num_spilt {
public static void main(String[] args) {
//从键盘录入一个三位数,获取其个位、十位、百位
// 1.键盘录入
Scanner sc = new Scanner(System.in);
System.out.println("请输入一个三位数");
int num = sc.nextInt();
// 2.获取个位,十位,百位
int ge = num % 10;
int shi = num /10 % 10;
int bai = num /100 % 10;
//3.给输出添加提示
System.out.println("个位是" + ge);
System.out.println("十位是" + shi);
System.out.println("百位是" + bai);
}
}
字符相加
byte, short, char 三种类型的数据在运算的时候,都会先提升为 int , 然后再进行计算
当 字符加字符
或 ‘字符加数字’ 的时候 ,会把字符先转为 ASCII 码表 对应的数字再相加。
在ASCII码表中,小写的 a 对应 97 ,大写的 A 对应 65
1 + 'a' = 98
'a' + "abc" = "aabc"
自增自减运算符
++ 加 变量的值加1
– 减 变量的值减1
单独使用 ++ 和 – 无论是放在变量前面还是变量后面,单独写一行的结果都是一样的
a++ 先用后加
++a 先加后用
赋值运算符
= 赋值
+= 加后再赋值
-= 减后再赋值
*= 乘后再赋值
/= 除后再赋值
%= 取余后再赋值
注意: +=、-=、/=、*=、%=
中都包含着一个强制类型转化
关系运算符
==
!=
>
>=
<
<=
注意:关系运算符的结果都是boolean类型,要么是true,要么是false
**注意:千万不要把 == 误写为 = **
逻辑运算符
- & 逻辑与(且) 并且,两边都为真,结果才为真
- | 逻辑或 或者,两边都为假,结果才为假
- ^ 逻辑异或 相同为false,不同为true
- ! 逻辑非 取反
短路逻辑运算符
5. && 短路与 结果和 & 相同,但是具有短路效果
6. || 短路或 结果和 | 相同,但是具有短路效果
- << 左移 向左移动 低位补0
- >> 右移 向右移动,高位补0或1
- >>> 无符号 无符号右移 向右移动,高位补0
注意:如果 && (||) 如果左边的表达式可以确定程序运行结果,则右边的表达式无需继续执行
最为常用的 逻辑运算符,&&,||,!
三元运算符
格式:关系表达式?表达式1:表达式2;
例:求两个数的最大值?
max = num1>num2?num1:num2;
注意: 运算符的优先级 : 小括号优先于所有
原码,反码,补码
原码:十进制数的二进制表现形式,最左边的位是符号位,0为正,1为负
反码:正数的反码补码是其本身,负数的反码是符号位不变,其余为取反
补码:正数的补码是其本身,负数的补码是在其反码的基础上+1(补码还能多记录一个特殊的值-128,该数据在1个字节下,没有原码和反码)
反码出现的目的 为了解决原码不能计算负数的问题而出现的
补码出现的目的 为了解决负数计算时跨0的问题而出现的
在计算机中,数据的存储都是以补码的形式进行的
流程控制语句
判断
if
if的第一种格式:
if(关系表达式){
语句体;
}
if的第二种格式:
if(关系表达式){
语句体1;
}
else{
语句体2;
}
if的第三种格式:
if(关系表达式){
语句体1;
}
else if(关系表达式){
语句体m;
}
........
else{
语句体n;
}
switch
switch(表达式){
case 值1:
语句体1;
break;
case 值2:
语句体2;
break;
......
default:
语句体n+1;
break;
}
格式说明:
- 表达式:(将要匹配的值)取值byte,short,int,char。
- case: 要和表达式作比较的值
其他知识点:
3. default 的位置和省略:default可以放在任意位置,而不是最下面
4. case穿透:如果break省略的话,如果表达式匹配成功,会直接执行匹配成功后的所有的case的结果,直到遇到break或着switch结束。
使用场景:如果多个case语句体重复,那么我们可以考虑利用case穿透来优化代码。
- switch新特性使用大括号来省略break
case 1 -> {语句体;} //如果 {} 中只有一行代码的话,则大括号可以省略
循环
for
for(初始化语句;条件判断语句;条件控制语句){
循环体语句;
}
/*
1. 执行初始化语句
2. 执行条件判断语句,看结果为T or F
如果为F,循环结束
如果为T,执行循环语句
3. 执行条件控制语句
4. 回到2继续执行条件判断语句
*/
while
初始化语句;
while(条件判断语句){
循环体语句;
条件控制语句;
}
do…while
初始化语句;
do{
循环体语句;
条件控制语句;
}while(条件判断语句);
// 至少循环一次
无限循环
for(;;){
代码块;
}
while(true){
代码块;
}
do{
代码块;
}while(true)
跳转控制语句
continue
break
数组
介绍
数组:一组容器,可以用来存储同种类型的多个值
定义和初始化
定义:
int [] array
int array[]
初始化:为数组容器开辟空间,并将数据存入容器的过程
静态初始化:
完整格式:数据类型[] 数组名 = new 数据类型[] {元素1,元素2,元素3};
int[] array = new int[]{1,2,3…};
简略格式:double[] array = {1,2,3};
动态初始化:
格式: 数据类型[] 数组名 = new 数据类型[数据长度]
int[] array = new int[3]
静态初始化:直接设定数组中所有的元素,无需显式的指出数组的长度
动态初始化:只设定数组的长度,不需要指定数组中的具体的元素
数组的长度 : 数组名.length
方法
方法定义
格式:
//定义:
public static 返回值类型 方法名(){
代码块;
return 返回值;
}
//调用
方法名()
例如:
//定义
public static int method(int num1,int num2){
int result = num1 + num2;
return result
}
//参数
int result = method(10,20);
System.out.println(method(10,20))
方法与方法之间是平级的,不能相关嵌套
方法重载
定义:
- 同一个类中的,定义了多个同名的方法,这些同名的方法具有相同的功能
- 每个方法具有不同的参数类型或参数个数,这些同名的方法,就构成了重载关系;
- Java 虚拟机 会 通过参数的不同来区分同名的方法
方法的内存
基本数据类型
引用数据类型: 数组,数据值存储在其他空间中,自己空间中存储的是地址值
方法值的传递
传递基本数据类型时,传递的是真实的数据,形参的改变,不影响实际参数的值
传递引用数据类型时,传递的是地址值,形参改变,实际的值也会发生改变
二维数组
-
静态初始化:
- 格式:数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2},{元素3,元素4}}
- 范例:int[][] array = new int[][] {{1,2},{3,4}}
- 简略:int[][] array = {{1,2},{3,4}}
- 格式:数据类型[][] 数组名 = new 数据类型[][]{{元素1,元素2},{元素3,元素4}}
-
动态初始化
- 范例:int[][] array = new int[3][5];
面向对象
类和对象
类
public class 类名{
1. 成员变量
2. 成员方法
3. 构造器
4. 代码块
5. 内部类
}
对象
构造方法
标准的javabean
例:
package XuXiang_learn;
public class User {
//属性
private String uesrname;
private String password;
private String email;
private String gender;
private int age;
//快捷键 alt + insert (+ fn)
// 插件 ptg 一秒生成
public User() {
}
public User(String uesrname, String password, String email, String gender, int age) {
this.uesrname = uesrname;
this.password = password;
this.email = email;
this.gender = gender;
this.age = age;
}
/**
* 获取
* @return uesrname
*/
public String getUesrname() {
return uesrname;
}
/**
* 设置
* @param uesrname
*/
public void setUesrname(String uesrname) {
this.uesrname = uesrname;
}
/**
* 获取
* @return password
*/
public String getPassword() {
return password;
}
/**
* 设置
* @param password
*/
public void setPassword(String password) {
this.password = password;
}
/**
* 获取
* @return email
*/
public String getEmail() {
return email;
}
/**
* 设置
* @param email
*/
public void setEmail(String email) {
this.email = email;
}
/**
* 获取
* @return gender
*/
public String getGender() {
return gender;
}
/**
* 设置
* @param gender
*/
public void setGender(String gender) {
this.gender = gender;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "User{uesrname = " + uesrname + ", password = " + password + ", email = " + email + ", gender = " + gender + ", age = " + age + "}";
}
}
基本数据类型 : 数据值存储在自己的空间中,赋值给其他的变量,也是赋的真实的值。
引用数据类型 : 数据值是存储在其他空间中,自己的空间存储的是地址值。赋值给其他的变量,赋的是地址值。
this关键字
this的作用:区分局部变量和成员变量
this的本质:所在方法调用者的地址值
字符串
概述
Java的String字符串是不会改变的,一旦创建不能更改
创建
- 直接赋值
- new方法
- 空参构造:String s2 = new String();
- 根据字符数组创建一个新的字符串对象: String s3 = new String(chs)
- 根据byte数组创建一个新的对象
字符串的比较
- == 比较
- 基本数据类型,比的是数据值
- 引用数据类型,比的是地址值
- 比较内容是否一致
- equals :
boolean result1 = s1.equals(s2);
不忽略大小写 - equalsIgnoreCase :
boolean result2 = s1.equalsIgnoreCase(s2);
忽略大小写
- equals :
注意 键盘录入的字符串是被new出来的
StringBuilder
作用 提高字符串的操作效率
代码 StringBuilder sb = new StringBuilder("abc")
常用方法
- public StringBuilder append(任意类型) 添加数据,并返回对象本身
- public StringBuilder reverse() 反转容器中的内容
- public int length() 返回长度
- public String toString() 通过toString() 把 StringBuilder 转为 String
public class SB {
public static void main(String[] args) {
// 创建对象
StringBuilder sb = new SringBuilder("abc");
// 添加对象
sb.append(1);
sb.append(2.3);
sb.append(true)
sb.reverse();
int len = sb.length();
System.out.println(len);
}
}
public class SB {
public static void main(String[] args) {
//创建对象,添加字符串
StringBuilder sb = new StringBuilder();
sb.append("aaa");
sb.append("bbb");
sb.append("ccc");
System.out.println(sb);
// 把StringBuilder 变成字符串
String str = sb.toString();
System.out.println(str);
}
}
StringJoiner
public class SJ {
public static void main(String[] args) {
StringJoiner sj = new StringJoiner("---");
sj.add("aaa").add("bbb").add("ccc");
System.out.println(sj); //aaa---bbb---ccc
}
}
public class SJ {
public static void main(String[] args) {
StringJoiner sj = new StringJoiner(",","开始","结束");
sj.add("aaa").add("bbb").add("ccc");
System.out.println(sj); //开始aaa---bbb---ccc结束
String str = sj.toString();
System.out.println(str);
}
}
字符串的原理
集合
集合和数组的区别?
长度:数组长度固定,集合长度可长可短
存储类型:数组可以存基本数据类型,也可以存引用数据类型;集合可以存引用数据类型,但是当存储基本数据类型时,需要把基本数据类型转换成包装类。
ArrayList
集合的增删改查
package XuXiang_learn;
import java.util.ArrayList;
public class ArrayListDemo1 {
public static void main(String[] args) {
// 1 创建对象
// 泛型:
ArrayList<String> list = new ArrayList<>();
// 添加元素
list.add("aaa");
list.add("bbb");
list.add("ccc");
// 删除元素
// 1.直接删除元素; 2.根据索引删除,会把 删除的元素进行返回
list.remove("aaa");
String str = list.remove(1);
// 修改元素 根据索引修改,会把 被覆盖的 元素 返回
String result = list.set(0,"ddd"); // 返回 bbb
// 查询元素
String s = list.get(0); //返回ddd
// 获取集合长度
int length = list.size();
// 遍历
for(int i = 0; i < list.size(); i++){
String str1 = list.get(i);
System.out.println(str1);
}
}
}
继承
- Java只能单继承:一个类只能继承一个直接父类
- Java不支持多继承,但支持多级继承
- Java中所有的类都直接或者间接的继承于Object类
// 猫继承动物类
public class Cat extends Animal{
}
注意:子类只能访问父类中的非私有的成员
子类可以继承父类的哪些东西?
-
构造方法不能被子类继承
-
成员变量 无论是私有或者非私有,都可以被直接继承。私有的成员变量不能直接被访问使用,只能通过get、set方法使用。
-
成员方法:虚方法表上的能被继承,否则不能
虚方法
继承中 -
成员变量的访问特点:就近原则 先在局部位置找,然后在本类成员位置找,然后在父类成员位置找,逐级往上。
- this 调用自身的成员变量
- super 调用父类的成员变量(在子类中最多只能调用一个super)
- 遇到了重名情况的下,三种访问方式:
name
this.name
super.name
-
成员方法的访问特点 就近原则
方法的重写:当父类方法不能满足子类现在的需求,所以需要对该方法进行重写。
书写格式:在继承体系中,子类出现了和父类一模一样的方法声明,我们就称这个方法是重写的方法。
@Override 重写注释
- @Override 是放在重写后的方法上的,校验子类重写时语法是否正确。
- 加上注解后如果有红色波浪线,则表示语法错误。
- 建议重写方法都要加上Override ,代码更加安全优雅。
重写的注意事项
构造方法的访问特点
- 父类中的构造方法不会被子类继承
- 子类中所有的构造方法默认先访问父类中的无参构造,再执行自己
- 如果想调用父类的有参构造,则必须手写super来进行调用。
多态
多态调用成员的特点
- 变量调用:编译看左边,运行也看左边
- 方法调用:编译看左边,运行看右边