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集合–泛型集合
如果对你有所帮助，请点赞，收藏，关注。给我一些反馈，谢谢！
1245
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
