本文详细介绍了Java编程的基础概念，包括类的继承、多态性、对象数组的使用以及内存解析。重点讲解了继承的原理和方法重写，多态的实现方式以及异常处理的机制，包括自定义异常。此外，还涵盖了对象数组的实例化和内存分配，以及Java内存结构的解析。通过对这些基础知识的掌握，读者可以更好地理解和运用Java语言。
目录
前言
该篇是自己在学习Java的比较基础的一些知识点
一.继承
1.继承类格式 class A extends B{}
一旦 子类继承父类后，子类中就获取了父类声明的所有的属性，方法
特殊的对于私有属性是可以继承但是无法直接调用需要通过设置public get set方法来调用，方法可以调用说明
2.子类继承父类以后，还可以声明自己特有的属性和方法，实现功能的拓展
extends ：扩展，延展
3.如果没有显示的声明一个类的父类的话，则此类继承与java.lang.Object类（所有的Java类都直接或间接继承object类
4.方法的重写（override）子类可以对父类的 同名同参 的方法进行覆盖重写
重写规范 ： 同名同参
权限修饰符 不小于父类同名方法，子类不能重写父类private方法因为无法调用
返回值 类型相同
异常类型，不大于父类被重写的方法抛出的异常类型
5.super关键字的使用（理解为父类） super可以调用 属性，方法，构造器
二.多态
多态性 （运行时行为）
1.父类的引用指向子类的对象
2.只能调用父类中声明的方法，我们实际执行是子类重写父类的方法，编译看左边，运行看右边
Person man = new Man();
（子类中定义与父类同名同参的方法，为虚拟方法）
3.前提条件： 类的继承关系；方法的重写
4.对象多态性只适用于方法，不适用属性 编译看左边，运行看右边
有了对象的多态性以后 ，内存中那种实际上加载了子类持有的属性和方法，但是由于变量声明为父类类型，导致编译时，
只能调用父类中声明的属性和方法，子类持有的属性和方法不能调用。
如何调用子类特有的方法，使用强制类型转换符，（向下转型，使用强制类型转换符）
三.对象数组
对象数组的使用方法
先声明在赋值
内存解析，先声明，栈中只有数组首地址，堆中已经有空数组，全是null
实例化之后，空数组都会被赋值，都有地址不是null
public class Java2{
public static void main (String[] args){
//声明Student对象数组
Student[] students = new Student[20];
for (int i =0; i <students.length;i++){
students[i] = new Student();
students[i].number = (i+1);
students[i].state = (int)Math.random();
students[i].score = (int)Math.random()*100;
System.out.println("xxueshetgn "+students[i].number +students[i].score+students[i].state);
}
}
}
class Student{
int number;
int state;
int score;
}四.内存解析
JVM内存结构
编译完源程序以后，生成一个或多个字节码文件。
我们使用JVM中的类的加载器和解释器对生成的字节码文件进行解释运行。
意味着，需要将字节码文件对应的类加载到内存中，涉及到内存解析
内存区域、
1.虚拟机栈 将局部变量存储在栈结构中
2.堆，我们将newd出来的结构加载到空间中。补充：对象的属性（非static）加载到堆空间中
方法区：类的加载信息，常量池，静态域
内存解析
1.引用类型的变量，只可能存储两类值，：null与 地址值（含变量的类型 ）
五.包装类
包装类的使用
| 基本数据类型 | byte | short | int | long | float | double | boolean | char |
| 包装类 | Byte | Short | Integer | Long | Float | Double | Boolean | Characte |
自动装箱
int in1= 10；
Interger in2 = in1;
自动拆箱
int in3 = in2
六.代码块
{
}
static{
}
1.代码块的作用，用来初始化类和对象
2.代码块，如果可以修饰的话，只能使用static
3.分类静态代码块，非静态代码块
4.静态代码块
》可以有输出语句
》随着类的加载而执行，而且只执行一次， 顺序执行
》静态代码块的执行优先于非静态代码块执行
》静态代码块只能调用静态的方法 属性，不能调用非静态的结构
5.非静态代码块
》可以有输出语句
》随着对象的创建而调用
》每次创建一个对象都会执行一次非静态代码块，
七.抽象
1.抽象
2.可以用来修饰的结构，类，方法
3.abstract修饰类：抽象类
》不可被实例化
》抽象类中一定有构造器，便于子类对象实例化调用
4.abstract修饰方法：抽象方法
》抽象方法只有方法声明，没有方法体
》包含抽象方法的类，一定是一个抽象类。反之，抽象类是可以没有抽象方法的
》若子类重写了父类中所有的抽象方法后，此子类方可实例化（所以不可以修饰私有方法静态方法，final方法，final类）
public class PersonTest {
Public static void main(String[] args){
Method(new Student());匿名对象
Worker worker = new Worker();
method (worker);//正常表达，非匿名的类的非匿名的对象
method（new Worker()）;//非匿名类的匿名对象
Person p = new Person(){ //😊😊😊😊注意抽象类不能被创建对象，此时拿父类的名字充当了一下，此时应该说是抽象类的匿名子对象
@override
Public void eat(){
System.out.println("");
}
@override
Public void breath(){
System.out.println("");
}
}
method（p）;
}
Public static void method1(Person p){ //多态的方式
P.eat();
P.walk();
}
}
Class Worker extends Person{
//Person 是抽象类
@override
Public void eat(){
}
@override
Public void breath(){
}
}八.接口
1.接口使用interface来定义
2.Java中接口和类是并列的两个结构
3.如何定义接口，定义接口中的成员
3.1 JDK7及以前：只能定义全局常量和抽象方法
全局常量 public static final 的但是可以省略
抽象方法 public abstract的
3.2JDK8：1.定义全局常量和抽象方法
2.定义静态方法，默认方法
4.接口中是不能定义构造器，意味着接口不可以实例化
5.Java开发中，接口都通过让类去实现的方式来使用 implements
如果实现类覆盖了接口中所有的抽象方法，则此实现类就可以实例化
如果没有，则此实现类仍为一个抽象类
6.Java类可以实现多个接口 ------》弥补了Java的单继承性
Public class S extends father implements M,K(){
}
7.接口与接口之间可以继承而且可以多继承
8.接口的具体使用 能体现多态性
9.接口实际上是一种规范
九.内部类
1.Java中允许一个类A声明再另一个类B中，则类A就是内部类，类B就是外部类
2.内部类的分类：成员内部类（静态，非静态），局部内部类（方法内，代码块内，构造器内）
成员内部类：
A。
一方面：作为外部类的成员
》调用外部类的结构
》可以被static修饰
》可以被四种权限修饰符修饰
另一方面：作为一个类
B。
》实例化成员内部类
//创建静态成员内部类（要想实例化静态成员内部类，就不需实例化外部类，因为静态成员靠类来调用）
Person.Dog dog = new Person.Dog();
//创建非静态成员内部类 (先实例化外部类的对象，只有外部类实例化才能调用成员内部类)
Person p = new Person();
Person.Bird bird = p.new Bird();
C。
》内部类调用外部类结构
同名不区分
不同名需要"."来调
局部内部类：
一种常用情况
Public Comparable getComparable(){
Class MyComparable implements Comparable{
@override
Public int compareTo(Opbject o){
return 0;
}
}
Return new Mycomparable();
}
另一种情况
匿名情况
十.异常
异常体系结构
Java.lang.Throwable
java.lang.Error:一般不编写针对性的代码进行处理
java.lang.Exception:可以进行异常处理
编译时异常（checked）
IOException
FileNotFoundException
ClassNotFoundException
运行时异常（unchecked）
NullPointerException
ArrayIndexOutOfBoundsException
ClassCastException
NumberFormatException
InputMismatch
ArithmaticException
异常对象的产生：
1.系统自动生成的异常对象
2.手动生成一个异常对象，并抛出 throw new 类型
异常处理机制一
一。异常处理：抓抛模型
过程一： “抛”：程序在正常执行过程中，一旦出现异常，就会在异常代码处生成一个对应的异常类的对象，
并将此对象抛出
一旦抛出对象以后，其后的代码就不再执行。
过程二：“抓”：可以理解为异常处理的方式：
Java异常处理方式
方式一 ;try-catch-finally
方式二：throws+异常类型
二。
方式一 ;try-catch-finally 处理编译时异常，运行异常仍可报错 （可以相互嵌套）
try{
//可能出现的异常代码
}catch (异常类型1 变量名1){
//处理异常方式1
}
catch (异常类型2 变量名2){
//处理异常方式2
}
catch (异常类型3 变量名3){
//处理异常方式3
}
。。。。。。
finally{
//一定会执行的代码‘如果遇到返回值return，优先级还是finally更高
（向数据库连接，输入输出流，网络变成Socket等资源，JVM是不能自动回收的，我们需要自己手动的及逆行资源的释放，此时的释放，就需要声明再finally中）
}
说明：
1.finally是可选的
2.使用try将可能出现的异常代码包装起来，在执行过程中，一旦出现异常，就会生成一个对应异常类的对象，根据此对象的类型，去catch中进行匹配
3.一旦try中的异常对象匹配到某一catch时，就进入到catch中进行异常处理，一旦处理完成，就跳出当前的try-catch结构（在没有些finally的情况）。继续执行其后的代码
4.catch中的异常类型如果没有子父类关系，则谁声明在上，谁声明在下无所谓I
catch中的异常类型如果有子父类关系，则子类在上，父类在下，否则报错。
5.常用的异常对象处理的方式：String getMessage() ; printStackTrace()
6.try 中定义的变量不能拿出来；
异常处理机制二
异常处理方式：throws +异常类型
1.“throws +异常类型” 写在方法声明处，指明此方法执行时，可能会抛出的异常类型。
一旦当方法体执行时，出现异常，仍会在异常代码处生成一个异常类的对象，此对象满足throws后异常类型时，此异常抛出。异常代码后续的代码就不再执行
体会：
一。
Try catch 真正处理异常
throws将异常抛给了方法的调用者，并没有真正将异常处理掉
二。
开发中如何选择try-catch 和throws ?
1.如果父类中被重写的方法没有throws方式处理异常，则子类重写的方法也不能使用throws,意味着如果子类重写的方法中有异常，必须使用try-catch-finally方式处理
2.执行的方法a中，先后调用了另外的几个方法，这几个方法是递进关系执行的，我们建议这几个方法使用throws的方式进行处理。而执行的方法a可以考虑使用try-catch方式进行处理
自定义异常
public class MyException extends RuntimeException{
Static final long serialVersionID=39479324857982;
Public MyException(){
}
Public MyException(String msg){
Super(msg)
}
扫一扫
203
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
