Java基础内容梳理
自己对Java基础做的一些简单梳理,如有错误请指正,我会及时修改!后续会对Java的其他知识做进一步的更新和梳理
如果对你有所帮助,可以帮忙点赞,收藏,关注,给我一些反馈,十分感谢!
数据类型
数据类型主要分为基本数据类型和引用数据类型两种。其中,基本数据类型分为数值类型和布尔类型。具体数据类型如下所示。
注:String是类,不是关键字。
举例
private static String getType(Object a) {
return a.getClass().toString();
}
public static void main(String[] args) {
byte a=0;
short b=1;
int c=10;
long d=20L;
float e=10;
double f=20.0;
char g='a';
boolean h=true;
System.out.println(a+"===>"+getType(a)+"==="+Byte.SIZE);
System.out.println(b+"===>"+getType(b)+"==="+Short.SIZE);
System.out.println(c+"===>"+getType(c)+"==="+Integer.SIZE);
System.out.println(d+"===>"+getType(d)+"==="+Long.SIZE);
System.out.println(e+"===>"+getType(e)+"==="+Float.SIZE);
System.out.println(f+"===>"+getType(f)+"==="+Double.SIZE);
System.out.println(g+"===>"+getType(g)+"==="+Character.SIZE);
System.out.println(h+"===>"+getType(h));
}
变量和常量
变量的命名规范
- 首字母小写,后面单词首字母大写 见名知意
- 见名知意
局部变量
局部变量: 定义在方法中或者方法声明上的变量。
- 没有默认值
- 内存:存储在栈中的方法中
- 生命周期:随着方法的存在而存在,随方法消失而消失
- 作用域:方法外无法使用,只能在方法内使用
举例
pubilic void get(int a){
//a,b都是局部变量
int b=0;
}
类变量
类变量: 定义在类中方法外的变量。
- 有默认值
string 默认为null
int默认为0
Boolean默认为false
double默认为0.0
char默认为空格 - 内存位置:堆中的对象中
- 生命周期:随对象的存在而存在,随对象的消失而消失
- 作用域:在类中的方法都可以使用
举例
public class Person{
//类变量/属性
//可以使用private,设置为私有属性,无法在类外调用
private int age;
//public类型属性,可以在其他类中创建对象,并调用
public String name;
public double height;
//类方法
public void eat(){ }
}
实例变量
实例变量: 从属于对象。
- 默认值为0或者false
举例
public class Student{
Person person=new Person();
//无法调用
System.out.println(person.age);
//可以正常调用
System.out.println(person.name);
}
常量
- 使用final定义
- 命名规范:大写字母加下划线
运算符
运算符类型 | 运算符 |
---|---|
算术 | +,-,*,/,%,++,– |
赋值 | = |
关系 | <,>,>=,<=,!= |
逻辑 | &&,||,! |
位 | &,|,^,~,>>,<< |
条件 | ? : ---- x?y:z ---- x为true,返回y,反之,返回z |
扩展 | +=,-= |
java程序流程控制
Scanner类简单用法
用户交互,需要使用Scanner类
- next()
读取到有效字符后结束
有效字符之前遇到空白会自动去除
必须先输入有效字符后才能用空白符作为分隔符或结束符
不能得到带有空格的字符串 - hasNext()
用来查看next()的输入 - nextLine()
以Enter为结束,回车之前的所有字符都可以被获取
可以获取空白符 - hasNextLine()
用来查看nextLine()的输入 - 直接输入特定类型的方法
nexInt()
nexFloat()
nexDouble() - Scanner输入类,属于IO流,使用完后需要关闭,以免占用资源
scanner.close();
方法
- 原子性:一个方法只完成一个功能,方便后期扩展。
- Java是值传递,参数传递时传递的是值,不是地址。
- 方法重载
同一个类中可以有相同名称的方法
参数列表必须不同
方法返回类型可以相同也可以不同 - 可变参数
一个方法只能有一个可变参数
可变参数必须为最后一个参数
方法名(修饰符… 参数名称) - 递归: 尽量避免递归,防止栈溢出
- static定义的方法,在类加载的时候就已经加载了
数组
//静态初始化
int[] a={1,2,3}
//动态初始化
int[] a=new int[10];
a[0]=1;
- 数组中的内容可以是任何数据类型,包括基本类型和引用类型
- 数组也是对象,数组元素等于对象的成员变量
- 稀疏数组:用于保存只有少数有用值的数组
- 数组排序(具体细节等有时间单写一篇文章)
二分排序
快速排序
冒泡排序
堆排序
。。。等等
面向对象Object-Oriented Programming(OOP)
本质: 以类的方式组织代码,以对象的组织(封装)数据
类
类: 一种抽象的数据类型,是某一类事物的整体描述。 所有类默认继承object类
class 类名{
类的属性
类的方法
}
- 属性:事物的外在特征,人:姓名,年龄,性别等
- 方法:事物所具备的功能,人:吃,喝,睡等
- 构造方法
- 形式
- 和类名相同
- 没有返回值
- 作用
- 创建对象
- 用来给对象的属性进行初始化
- 定义有参构造方法后,如果想要定义无参的对象,必须显示的定义一个无参的构造方法。
- 形式
public class person{
public int age;
//构造方法--默认存在一个空的构造方法
// Person p=new Person();
// new本质上是在调用构造方法
public person(){}
//这也是构造方法但是需要给age赋值
//新建对象时
//Person p=new Person(18);
public person(int age){
this.age=age;
}
}
- 类中的方法类型
- 静态方法
- 类加载时就加载
- 只加载一次
- 匿名方法
- 创建对象时加载
- 非静态方法
- 创建对象时加载
- 静态方法
- 类是单继承的,但是接口可以多继承
- 一个java类中只能有一个public class类,但是可以有多个class 类
- 内部类:定义在类内部的类
public class person{
public int age;
public String name;
public void eat(){}
//内部类
class Student{
public int ID;
public void learn(){}
}
}
对象
对象: 是抽象概念的具体实例
- 对象能执行那些方法主要看左边的类型,和右边的new 关系不大
//创建一个Person对象
//这时会分配空间,进行默认初始化
//创建一个对象本质上是在调用构造方法
Person person=new Person();
匿名对象
- 创建:new 类名()
- 只能使用一次
- 匿名对象可以作为实际参数进行传递
封装
- 将属性私有
- get/set :使用快捷键alt+insert,设置所有数据的get/set方法
- 作用
- 提高程序安全性,保护数据
- 隐藏代码的实现细节
- 统一接口
- 增加系统可维护性
继承 extends
- 本质是对某一批类的抽象
- super
- 使用父类的非私有的属性或方法
- 调用父类的构造器必须在第一句
- 只能出现在子类的方法或者构造方法中
- super和this不能同时调用构造方法
- 重写 @override
- 子类重写父类的方法
- 只能重写公有的方法
- 方法名要相同
- 参数列表要相同
- 修饰符可以扩大但不能缩小
- public>protected>default>private
- 抛出的异常:范围可以缩小但不能扩大
- 重写的原因,父类的功能子类不一定需要或者满足
多态
- 可以实现动态编译
- 子类转换为父类,可能丢失一些自己的方法
- 多态是方法的多态,属性没有多态
- ClassCastException类型转换异常
- static方法属于类,不能重写
- private方法也不能重写
- 多态存在的条件
- 有继承关系
- 子类重写父类的方法
- 父类引用子类对象
- instanceof
- X instanceof Y
- X和Y存在父子关系true,反之=False
public class Person {
}
public class Student extends Person {
}
public class Teacher extends Person {
}
public class Application {
public static void main(String[] args) {
//Object>Person>Student
//Object>Person>Teacher
//Object>String
Object object=new Student();
System.out.println(object instanceof Student);//true
System.out.println(object instanceof Person);//true
System.out.println(object instanceof Object);//true
System.out.println(object instanceof Teacher);//false
System.out.println(object instanceof String);//false
System.out.println("=================================");
Person person=new Student();
System.out.println(person instanceof Student);//true
System.out.println(person instanceof Person);//true
System.out.println(person instanceof Object);//true
System.out.println(person instanceof Teacher);//false
// System.out.println(person instanceof String);//编译报错
System.out.println("=================================");
Student student = new Student();
System.out.println(student instanceof Student);//true
System.out.println(student instanceof Person);//true
System.out.println(student instanceof Object);//true
// System.out.println(student instanceof Teacher);//编译报错
// System.out.println(student instanceof String);//编译报错
}
}
抽象 abstract
抽象类: abstract class 类名
public abstract class Person{}
- 不能创建抽象类的对象,只能靠子类来实现
- 抽象类中可以有抽象方法和普通方法
抽象方法: abstract 类型 方法名
public abstract void run();
- 只有方法名,没有方法的实现
- 抽象方法只能在抽象类中
接口 interface
- 只有规范,无法自己写方法
- 接口都需要实现类,implements
- 实现类必须重写接口中的方法
- 接口中定义的方法都是抽象的
- 接口中的属性默认都是常量
异常
异常: 程序运行中出现的不正常现象,如果不能对这些现象进行正确处理可能导致程序不能运行,造成不必要的损失。
异常分类
Throwable: 可抛出的一切错误或者异常的父类
- Error:JVM,硬件,执行逻辑错误,不能手动处理
- Exception:程序再运行和配置中产生的问题,可处理
- 运行时异常:RuntimeException以及其子类
- 检查时异常:Exception以及其子类,RuntimeException除外
常见的异常如下图所示:
异常处理的方法:
- 可以使用多重catch捕获异常
- 捕获异常时,子类异常在前,父类异常在后
- 发生异常时按顺序逐个匹配,且只执行第一个与异常匹配的catch语句
- try…finally…不捕获异常,将异常向上一级抛出
- finally不执行的唯一情况是退出java虚拟机
- finally可写可不写
案例
public class testException {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
int re= 0;
try {
System.out.println("输入第一个数:");
int n1=scanner.nextInt();
System.out.println("输入第二个数:");
int n2=scanner.nextInt();
re = n1/n2;
} catch (ArithmeticException e){
// e.printStackTrace();
System.out.println("算术异常发生了");
} catch (InputMismatchException e){
// e.printStackTrace();
System.out.println("输入类型不匹配异常发生了");
}catch (Exception e) {
// e.printStackTrace();
System.out.println("异常出现了");
} finally {
System.out.println("资源释放");
}
System.out.println("结果为:"+re);
System.out.println("程序结束了");
}
}
运行结果:
声明异常和抛出异常
声明异常:
- 在方法名后添加throws关键字,并添加想要声明的异常类型
- 可以声明多个异常,用逗号隔开
案例
public class testExceptionThrows {
public static void main(String[] args) {
try {
divide();
} catch (Exception e) {
System.out.println("异常发生");
}
}
private static void divide() throws Exception,RuntimeException {//可声明多个异常,用逗号隔开
Scanner scanner=new Scanner(System.in);
int re= 0;
System.out.println("输入第一个数:");
int n1=scanner.nextInt();
System.out.println("输入第二个数:");
int n2=scanner.nextInt();
re = n1/n2;
}
}
运行结果
抛出异常: 根据代码的执行情况去抛出一个异常,可以结合自定义异常,准确抛出代码执行过程中可能出现的异常。
- 使用thorw关键字,在程序运行出现预期之外的数据时抛出异常
- 如果抛出的异常类型时Exception,需要在先声明异常或者使用try-catch处理异常
案例
public class testExceptionThrow {
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
System.out.println("请输入学生成绩:");
int sorce=scanner.nextInt();
//如果输入的学生成绩不符合正常情况就需要抛出异常
if (sorce<0||sorce>100){
//AgeException自定义异常
throw new AgeException("输入成绩不符合规则");
}else{
System.out.println("该学生的成绩为:"+sorce);
}
}
}
自定义异常
自定义异常的构造:
- 继承Exception或者其子类
- 添加构造方法
目的: 让抛出的异常名称更加准确,可以做的见文知意,从而提高项目维护和debug的效率
案例
Student类
public class Student {
private String name;
private int age;
public Student(){}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
//手动重写toString方法
/*public String toString(){
return name+":"+age;
}*/
//alt+insert自动重写toString方法
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
自定义异常:
public class AgeException extends RuntimeException {
public AgeException() {
}
public AgeException(String message) {
super(message);
}
public AgeException(String message, Throwable cause) {
super(message, cause);
}
public AgeException(Throwable cause) {
super(cause);
}
public AgeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
super(message, cause, enableSuppression, writableStackTrace);
}
}
其他相关文章
- Java知识梳理:Java知识梳理
- Java知识梳理–内部类:Java知识梳理–内部类
- Java常用类–Object类:Java常用类–Object类
- Java常用类–包装类:Java常用类–包装类
- Java常用类–String类:java常用类–String类
- Java常用类–时间相关类:Java常用类–时间相关类
- Java常用类–BigDecimal类和System类:Java常用类–BigDecimal类和System类
- Java集合–Collection集合:Java集合–Collection集合
- Java集合–泛型集合:Java集合–泛型集合
如果对你有所帮助,请点赞,收藏,关注。给我一些反馈,谢谢!