目录 :
1 ) . 面向对象(异常概述)
2 ) . 面向对象(异常Try-catch)
3 ) . 面向对象(异常声明throws)
4 ) . 面向对象(多异常处理)
5 ) . 面向对象(自定义异常)
6 ) . 面向对象(throw和throws的区别)
7 ) . 面向对象(RuntimeException)
8 ) . 面向对象(异常练习)
9 ). 面向对象(异常-finally)
10 ). 面向对象(异常-处理语句其它格式)
11 ). 面向对象(异常-覆盖时的异常特点)
12 ). 面向对象(异常-练习)
13 ). 面向对象(异常-总结)
14 ). 面向对象(练习四)
15 ). 面向对象(包package)
16 ). 面向对象(包与包之间访问)
17 ). 面向对象(导入import)
18 ). 面向对象(jar包)
一
.
面向对象(异常概述)
1 ) . 概述 :
1.1 定义 : 异常就是程序在运行时出现的不正常情况而产生的
1.2 异常由来 : 问题也是现实生活的一部分,也是具体的事物,因此通过java的类的形式描述,并封装成对象,其实就是java对不正常情况进行描述后的对象体现
1.3 对异常的划分 :
[1] 一种是严重问题 : 对于严重的,java通过Error类进行描述 --> 对于Error的一般不编写针对性代码对其进行处理
[2] 一种是非严重问题 : 对于非严重的,java通过Exception类进行描述 -->对于Exception的可以使用针对性的处理方式进行处理
1.4 异常的最终类是Throwable --> 祖先是从由严重/非严重抽取出的共性特征,是Error和Exception都具有的共性内容 : 比如: 不正常信息,引发原因,反正都是病嘛
2 ) . 异常的体系 :
1.1 Error
1.2 Exception
[1] RuntimeException
[2]CheckException
小结 :
1. 问题封装成对象形成了异常2. 通过分类的方式阻隔,通过共性特点进行抽取,然后形成庞大的体系
二.
面向对象(异常Try-catch)
1 ) . Demo :
class Demo{int div(int a,int b){return a/b;}}class ExceptionDemo1{public static void main(String args[]){// int result = new Demo().div(4,1);try{int result = new Demo().div(4,0);System.out.println("result:"+result);}catch( Exception e){System.out.println("异常信息:"+e.getMessage());System.out.println("--------------------------");System.out.println("异常名称:异常信息:"+e.toString());System.out.println("--------------------------");System.out.println("异常名称:异常信息:异常出现的位置:");e.printStackTrace();System.out.println("--------------------------");}System.out.println("voer......" );}}
1.1 JVM默认的异常处理机制就是在调用printStackTrace方法去处理,打印异常的堆栈的跟踪相关信息
2 ) . 异常的处理方式 : -->java提供了特有的语句进行处理
try{内放需要被检测的代码;}catch(异常类 变量){内放处理异常的代码(处理方式);}finally{内放 一定会执行的语句;}
3 ). 对异常信息进行常见的操作 :
3.1 异常信息:"+e.getMessage()
3.2 异常名称:异常信息:"+e.toString()
3.3 异常名称:异常信息:异常出现的位置:" e.printStackTrace(); -->jvm虚拟机处理异常的默认方式
小结 :
1. try用来放需处理代码;catch对代码处理;finally返回必须返回的信息,throws 用来给方法标注有异常问题
三.
面向对象(异常声明throws)
1 ) . Demo :
class Demo{int div(int a,int b) throws Exception //用throw标注异常抛出{return a/b;}}class ExceptionDemo1{public static void main(String args[]) // throws Exception 也可通过抛出异常,和捕获异常两种方式都可解决{// int result = new Demo().div(4,1);try{int result = new Demo().div(4,0);System.out.println("result:"+result);}catch( Exception e){System.out.println("异常信息:"+e.toString());}System.out.println("voer......" );}}
2 ) . 处理异常的两种方式 :
2.1 抛出异常 : throws
在函数上声明异常 : 便于提高安全性,让调用者进行处理,不处理则编译失败
2.2 捕获异常 : try{} catch {} finaly{}
小结 :
1. Throws是用来抛出异常的,也是用来标注此方法也许有问题的标志
四.
面向对象(多异常处理)
1 ) . 对多异常处理情况:
1.1 声明异常时,建议声明更为具体的异常,这样处理可以更具体
1.2 若对方声明几个异常,就应对应几个Catch处理块,不要定义多余的catch块
若多个catch块中的异常存在继承关系,则父类异常catch块应放到最下面,避免父类把子类的也处理掉
1.3 建议在进行catch块处理时,内容一定要定义具体的处理方式,另外不要简单定义输出语句,e.printStackTrace() ;也不要简单书写简单输出语句;而是用一个文档记录下来 : 日常异常处理文件
2 ) . Demo:
class Demo{int div(int a,int b) throws ArrayIndexOutOfBoundsException,ArithmeticException{int[] arr = new int[a];System.out.println("arr:"+arr[4]);return a/b;}}class ExceptionDemo2{public static void main(String args[]){// int result = new Demo().div(4,1);try{int result = new Demo().div(3,0);System.out.println("result:"+result);}catch(ArithmeticException e){System.out.println("数字异常:"+e.toString());System.out.println("--------------------------");}catch( ArrayIndexOutOfBoundsException e){System.out.println("数组下边越界异常:"+e.toString());System.out.println("--------------------------");}/* catch( Exception e){System.out.println("异常的爸爸:"+e.toString());System.out.println("--------------------------");} */System.out.println("voer......" );}}
小结 :
1. 老大可处理小弟的,小弟不可处理老大的,因为小弟先处理小弟的,而后老大再处理老大的
五
.
面向对象(自定义异常)
1 ) . 引入 :
1.1 特定问题特进行研究定对待,若java无提供异常类,则需要自己根据java的对问题封装的思想,将特有问题进行自定义封装
2 ) . 如何自定义异常的注意要点 :
2.1 必须是自定义类继承Exception /error
[1] 继承exception的原因
一来是因为exception具有可抛性,二来exception和error是两大体系,具体原因具体继承即可
3 ). Demo : 抛异常是一级一级向上抛,方法到类也算是一级
class FushuException extends Exception{private int value;FushuException(String message,int value){ //因为继承了可以用此来接受信息super(message);this.value=value;}//自定义的方法public int getValue(){return value;}}class Demo{int div(int a,int b) throws FushuException{if(a<0)throw new FushuException("不能为负数",a);return a/b;}}class ExceptionDemo3{public static void main(String args[]){try{int result = new Demo().div(-2,1);System.out.println("result:"+result);}catch(FushuException e){System.out.println("存在的异常:"+e.toString());System.out.println("出现问题的位置:"+e.getValue());}System.out.println("over");}}
小结 :
1. 异常体系的特点是异常类和异常对象都可被抛出,错误体系也是
六.
面向对象(throw和throws的区别)
1 ) . throw和throws的区别 :
1.1 位置 :
[1] throws使用在函数上
[2] throw使用在函数内
1.2 功能 :
[1] throws后跟的是(抛的是)异常类,可以跟多个,用逗号隔开
[2] throw后跟的是(抛的是)异常对象
小结 :
1. throw常用于抛自定义异常对象,throws常用于抛自定义异常类/异常类
七.
面向对象(RuntimeException)
1 ) . RuntimeException --> 他在Exception中是一个特殊的子类异常,是运行时异常
1.1 若在函数内容中抛出该异常,则函数上可以不用声明,编译一样通过
1.2 若在函数上声明该异常,则调用者可以不用进行处理,编译一样通过
1.3 原因是 : 只要抛出该异常则,表示一不需要调用者处理,二代码出现了无法继续运算的情况,需要处理,因此希望停止程序后,对代码进行修正
2 ) . 自定义异常的第一种继承选项 :
2.1 第一种是可选择继承exception ,当抛出该异常时,指程序也还有处理的可能
2.2 第二种是可选择继承RuntimeException,当抛出该异常时,指程序无法进行运算,即可抛出立即修改代码
3 ). 对于异常的两种 :
2.1 编译时被检测的异常 -->也就是函数内抛出,函数方法必须也抛出的异常
2.2 编译时不被检测的异常(运行时异常,runtimeException以及其子类) -->也就是函数内抛出,函数方法不用抛出的异常
4 ). Demo
class FushuException extends RuntimeException{private int value;FushuException(String message ){super(message);}}class Demo{int div(int a,int b){if(a<0)throw new RuntimeException("不能为负数");return a/b;}}class ExceptionDemo4{public static void main(String args[]){int result = new Demo().div(-2,1);System.out.println("result:"+result);System.out.println("over");}}
小结 :
1. 异常也分两种,一种try{}catch{}可解决异常(编译时异常),一种是无需解决直接抛出异常(非编译时异常)
八
.
面向对象(异常练习)
1 ) . Demo:
/*需求 : 毕老师用电脑上课分析 : 采用名次提炼法构思类步骤 :第一步 : 依据名次提炼法分析类第二步 : 构思可出现的异常并归类第三步 : 将可出现的异常与相关关联第四步 : 测试运行即可*/class LanPingException extends Exception{LanPingException(String message){super(message);}}class MaoyanException extends Exception{MaoyanException(String message){super(message);}}class NoplanException extends Exception{NoplanException(String message){super(message);}}class Computer{private int state=1;public void start() throws LanPingException,MaoyanException{if(state==2)throw new LanPingException("电脑蓝屏");if(state==1)throw new MaoyanException("电脑冒烟");System.out.println("Computer start......");}public void reset(){System.out.println("Computer reset......");}public void stop(){System.out.println("Computer stop......");}}class Teacher{private String name;private Computer computer;Teacher(String name){this.name=name;computer = new Computer();}public void prelect() throws NoplanException{try{computer.start();}catch(LanPingException e){computer.reset();}catch(MaoyanException e){test();throw new NoplanException("上课无法继续运行"+e.getMessage());}System.out.println(this.name+"prelect start......");}public void test(){System.out.println("自觉自习");}}class ExceptionDemo5{public static void main(String args[]){Teacher t = new Teacher("张老师");try{t.prelect();}catch(NoplanException e){System.out.println("出现原因:"+e.toString());System.out.println("放假吧");}}}
2 ) . 须知 :
2.1 名次提炼法
2.2 结构归类法
2.3 共性抽取法
2.4 高内聚,低耦合
九
.
面向对象(异常-finally)
1 ) . 简述 :
1.1 特点 : finally中存放的代码是一定会被执行的,因此其中应定义一定执行的代码
1.2 作用 : 通常用于结束某段程序或者关闭资源
2 ) . Demo:
/**/class NoException extends Exception{NoException(String message){super(message);}}class statementSqlMethod throws NoException{//需求案例 :/* 连接数据库 ;数据操作;//throw new SqlException();关闭数据库 ;//该动作,无论数据操作是否成功一定要执行,因为数据库资源有限*/try{//连接数据库 ;//数据操作;//throw new SqlException();}//捕获异常操作catch(SQLexception e){//通过自定义异常抛出信息,throw new NoException();}}class FuShuEexception extends Exception{FuShuEexception(String message){super(message);}}class Demo{int div(int a,int b) throws FuShuEexception{if(a<0)throw new FuShuEexception("除数为负数");return a/b;}}class ExceptionDemo6{public static void main(String args[]) throws FuShuEexception{try{int result = new Demo().div(-1,3);System.out.println(result);}catch(FuShuEexception e){throw new FuShuEexception("出现了负数的情况");}}}
小结 :
1. SqlException : 在数据库处理数据的过程中出现的异常是数据库异常2. 我们可以用java提供的异常类调用捕捉相关异常,而后在catch中throw抛出自定义异常好记录确切信息
3. 任何机器资源有限,必须关闭资源
十.
面向对象(异常-处理语句其它格式)
1 ) . 异常语句的三种格式 :
1.1 第一种 : try{}catch(){}finally{} -->检查代码捕获异常,处理异常,记录信息关闭资源
1.2 第二种 : try{}catch(){} --> 检查代码捕获异常,处理异常
1.3 第三种 : try{}finally{} -->检查代码捕获异常,记录信息关闭资源抛出异常
2 ) . 须知 : catch是用来处理异常的,若没有catch标志异常未处理,若该异常是检测时异常则函数上必须throws声明
3 ) . Demo:
//伪代码class MyException extends Exception{MyException(String message){super(message);}}class Method{try{throw new Exception();}catch(Exception e){throw MyException("出现异常....");}finally{//关闭资源}}class ExceptionDemo7{public static void main(String args[]) throws FuShuEexception{}}
小结 :
1. Try中不但可以放也许有异常的代码,也可放抛出异常代码2. catch中可以捕获异常处理异常抛出异常信息,
3. finally中可以放记录信息关闭资源抛出异常
十一.
面向对象(异常-覆盖时的异常特点)
1 ) . 异常在子父类覆盖中的体现 :
1.1 子类在覆盖父类时,若父类方法抛出异常,则子类的覆盖方法,只能抛父类的异常或者父类的子类异常
1.2 若父类方法抛出多个异常,则子类覆盖方法时,只能抛出父类异常的子集
1.3 若父类或接口中的方法没有异常抛出,则子类在覆盖方法时,也不可抛出异常,若子类方法发生了异常,必须就低try处理,绝不能抛
2 ) . Demo -->伪代码
class AException extends Exception{}class BException extends AException{}class CException extends Exception{}class Fu{void show() throws BException{}}class Zi extends Fu{void show() throws AException//BException //此处只能抛出AException或BException或不抛,不能抛CException{}}
小结 :
1. 若继承的父类有异常,则子类只能不抛,或抛父类的异常或父类子类的异常 -->原则是抛的异常父类能处理2. 若抛的异常父类不能处理则会挂掉,解决办法是在子类内部就处理掉,不抛
十二
.
面向对象(异常-练习)
1 ) . Text : --> 求长方形和圆形的面积,并用自定义异常捕获问题 --> 满意
/*需求 : 求长方形与圆形的面积分析 :1.长方形与圆形有共同功能,若是基本功能则抽出父类,若是辅助功能则抽出接口2.问题的抽象化成对象形成了异常,自定义值的异常*///共性接口interface Shape{double getArea();}//通用异常class NoValueException extends RuntimeException{NoValueException(String message){super(message);}}//长方形类class Rectangle implements Shape{private double lon,wid;Rectangle(double lon,double wid){if(lon<=0 || wid<=0)throw new NoValueException("非法字符");this.lon=lon;this.wid=wid;}public double getArea(){return (lon*wid);}}//圆形类class Round{private int rediaus;public static final double PI=3.1415926;Round(int rediaus){if(rediaus<=0)throw new NoValueException("非法字符");this.rediaus=rediaus;}public double getArea(){return (rediaus*rediaus*PI);}}//测试class ExceptionText{public static void main(String args[]){//长方形测试Rectangle rec = new Rectangle(1,2);double recresult=rec.getArea();System.out.println(recresult);//圆形测试Round rou = new Round(2);double rouresult=rou.getArea();System.out.println(rouresult);}}
小结 :
1. 基本功能可抽取出抽象类,附属功能可抽取出接口2. 抽取的两方面 : 功能抽取,属性参数抽取
3. void -->指不需要返回参数 ,其它的需要采用 renturn 返回参数
4. 采用异常封装问题的好处 : 问题处理代码和正常流程代码采用模块化的方式分开
十三
.
面向对象(异常-总结)
1 ) . 简述 :
1.1 异常是什么 ? 是对问题的描述,将问题进行对象的封装
2 ) . 异常体系 :
2.1 图例 :
Throwable|--Error|--Exception|--RuntimeException
2.2 异常体系的特点 :
[1] 异常体系中的所有类以及对象都具有可抛性,也就是说可以被throw和thorws关键字操作
[2] 只有异常体系具备可抛型这个特点
3 ).throw和throws的用法:
3.1 throw定义在函数内,用于抛出异常对象
3.2 throws定义在函数上,用于抛出异常类,可抛出多个,用逗号隔开
ps : 当函数内容有throw抛出异常对象,并未进行try处理,则必须在函数上声明,否则编译失败,RuntimeException异常除外
4 ).异常处理方式 : -->若函数声明 了异常,调用者需要处理,则处理方式可以throws也可以try
4.1 异常的两种 :
[1] 编译时被检测异常 -->该异常在编译时,若没有处理(没有抛也没有try)则编译失败,该异常被标识,代表可处理; -->可以处理的没处理出现的异常
[2] 运行时异常(编译时不检测)-->在编译时,不需要处理,编译器不检查,该异常发生,建议不处理,让程序停止,需要对代码进行修正-->建议不要处理的异常
4.2 异常处理语句 :
try{需要被检测的代码;}catch(){处理异常的代码;}fianlly{一定会执行的代码;}
[1] 三种处理语句格式 :
第一种 : try{}catch(){} 捕获异常;处理异常
第二种 : try{}finally{} 捕获异常抛出自定义异常信息;关闭资源
第三种 : try{}catch(){}finally{} 捕获异常;处理异常;抛出信息关闭资源
ps :
[1] finally中定义的通常是关闭资源代码,因为资源必须释放
[2] finally只有一种情况不会执行,是当执行到System.exit(0);finally不会执行
4 ).自定义异常
4.1 方式 :定义类继承Exception或者RuntimeException
4.2 目的 :
[1] 为了让该自定义类具备可抛性
[2] 为了让该类可调用父类的共性方法,从而具备操做方法的权利
ps : 当要定义自定义异常的信息时,可使用父类已定义好的功能,将信息传递给父类的构造函数
class MyException extends Exception{MyException(String message){super(message);}}
小结 : 自定义异常就是按照java的面向对象思想,将程序中出现的特有问题进行封装
5 ).异常的好处 :
5.1 将问题进行封装
5.2 将正确流程代码和问题代码相分离,便于阅读
6 ).异常的处理原则:
6.1 两种处理方式 : 要么try ,要么throws
6.2 调用到抛出异常的功能时,抛出几个就处理几个,可一个try对应多个catch
6.3 多个catch,父类的catch放到最下面
6.4 catch内,需要定义针对性处理方式,不要简单定义printStackTrace输出语句,也不要什么都不写
[1] 当捕获到的异常,本功能处理不了时,可以继续在catch中抛出 :
try{throw new Aexception();}catch(Aexception e){throw e;}
[2]若异常处理不了,但并不属于该功能出现的异常,可以将异常转换后,再抛出和该功能相关的异常
try{throw new Aexception();}catch(Aexception e){throw new Bexception();}
[3] 若异常可处理,当需要将异常产生的和本功能相关的问题提供出去让调用者知道并处理时,可将捕获异常处理后,转换新的异常
try{throw new Aexception();}catch (AException e){//对Aexception先处理然后throw new Bexception();}
比如 : 汇款的例子-->汇款失败则做出失败异常处理和返回失败信息
7 ).异常的注意事项 :
7.1 在子父类覆盖时 :
[1] 子类抛出的异常必须是父类的异常的子类或者子集-->也就是父类可处理的[2] 若父类或者接口没有异常抛出,子类覆盖出现异常,只能try不能throw
7.2 参阅 :
ExceptionTest.java 老师用电脑上课 --> ExceptionTest1.java 图形面积
十四.
面向对象(练习四)
1 ) . 总结重点
1.1 在具有继承关系时,子类的实例化过程是先实例化父类再实例化子类
1.2 在非runtimeException时,在函数内抛出异常,则函数方法必须throw,否则编译失败
1.3 某类实现了某接口还要调用某类的方法时,需要用this标注
1.4 非静态内部类中不可以定义静态变量,若内部类定义了静态变量,则该内部类必须被静态修饰
1.5 在重载中若要覆盖就必须有足够的权限也就是修饰符修饰
1.5 final
[1] 可修饰类,变量,函数 -->变量 :成员变量,静态变量,局部变量
[2] 修饰的类不可以被继承
[3] 修饰的函数不可以被覆盖
[4] 修饰的变量变常量,而且只能赋值一次
[5] 内部类只能访问被final修饰的局部变量
1.6 throw单独存在,下面不要定义语句,因为执行不到 -->类似的还有 return,break,continue
1.7 在异常语句格式中,多个catch时,父类的catch要放最下面
小结 :
1. 从main方法开始看 --> 自上而下2. 动态可变的都可在java中作为参数
十五
.
面向对象(包package)
1 ) .简述 : -->java中的包也就是文件系统中的文件夹
1.1 作用:
[1] 对类文件进行分类管理
[2] 给类提供多层命名空间
[3] 包也是一种封装形式
1,2 位置 :
[1] 写在程序文件的第一行
1.3 格式 :
[1] 类名的全称的是 包名.类名
2 ) . 编译以及运行 :
2.1 编译 : javac -d . PackageDemo.java -->编译可通过 -d 指定是目录文件, . 指定路径,也可写其他路径 . 指当前文件下
[1] 与之前区别在于 多了标注文件的参数和放文件的位置
2.2 运行 : java pack.PackageDemo -->运行的格式是 包名.类名
[1] 与之前区别在于格式上需要用包名.类名才有效
小结 :
1. 命令是基本功能,不同参数就是附属功能
2.想在当前目录访问其他目录内的文件,.则需要set classpath=路径 -->设置下类路径-->也就是告诉虚拟机你想在哪个目录下执行java程序所需的类或包
十六
.
面向对象(包与包之间访问)
1 ) . 知识点 :
1.1 类有两个修饰符可修饰 :
[1] default -->默认修饰符,对内提供的
[2] public -->公共的,对外提供的
1.2 图解 访问修饰符 :
2 ) . 包与包之间类的访问需要什么?
2.1 被访问的包中的类以及类中的成员public修饰
2.2 在继承关系下,不同包中的子类还可以直接访问父类中被protected权限修饰的成员
2.3 包与包之间可以使用的权限只有两种 : public ,protected
小结 :
1. 在继承关系下,A继承B,A想覆盖B的方法,,A权限必须是大于或等于B权限才能覆盖
2. 在一个类中,不可出现两个或两个以上的公有类和接口
十七
.
面向对象(导入import)
1 ) . 含有多个层级包的类如何创建对象 :
1.1 包名.包名.类名 变量名 = new 包名.包名.类名
[1] 如何改善创建对象 : 通过 import. 包名.包名.类名 在package修饰符之下,class修饰符之上定义
[2] 改善后的创建对象方式 : 类名 变量名 = new 类名;
2 ) . import -->简化类名的书写,用于导入包中的类,导入时建议不要使用*符号,会影响性能
[1] 需要哪个类就是import导入哪个类
[2]自定义包时避免包名重复,可使用url来完成定义,因url是唯一的 ;例 : package cn.itcast.dome
小结 :
1. JavaAPI结构 : API-->jar包-->jar子包-->上帝类-->类-->子类
十八.
面向对象(jar包)
1 ) . jar包 : jar包其实就是将多个java文件解压缩后形成的包
2 ) . jar命令的应用 :
3 ) . JDK内为何必须要有JRE?
JDK是编译工具,也就是java程序,想运行依靠jvm,而jvm就在jre当中,因此需要jre运行环境
4 ) .
4.1 java内存五大分区 :
详解 :
[1] 栈 --> 又称 堆栈, 是用户存放程序临时创建的局部变量,也就是说我们函数括弧“{}” 中定义的变量 , 把堆栈看成一个寄存、交换临时数据的内存区。
[2] 堆 --> 用于存放进程运行中被动态分配的内存段,它的大小并不固定,可动态扩张或 缩减
[3] BBS --> 用来存放程序中未初始化的全局变量和静态变量 ,作用是 维护开始和结束的地址,即总大小
[4] 数据段 --> 用来存放程序中已经初始化的全局变量和静态变量的一块内存区域, 分为只读数据段和读写数据段
[5] 代码段--> 指用来存放程序执行代码的一块内存区域
4.2 jVM内存五大分区 :
详解 :
[1] java栈(VM Stack)
--> 局部变量表 : --> 例如 : 基本数据类型的变量存储真值和引用数据类型的变量存储指向对象的引用
-->操作数栈: --> 用来运行程序中的所有运算
-->指向运行时常量池的引用--> 用来在运行时引入方法中所用到的常量
-->方法返回地址--> 运行之后返回的地方
-->附加信息 -->
每个java线程都有自己的java栈,互相隔离,互不干扰
[2] 本地方法栈(Native Method Stack) --> 与java栈原理类似,区别之处在于 java栈为执行java程序服务,而本地方法栈是为执行本地程序服务的
[3] 程序计数器(Program Counter Register) --> 用来指示执行哪条指令的
在JVM规范中规定，如果线程执行的是非native方法，则程序计数器中保存的是当前需要执行的指令的地址；如果线程执行的是native方法，则程序计数器中的值是undefined。
[4] 堆(Heap) --> 唯一一个程序员可以分配管理的区域,用来存储java对象本身以及数组,因为java中有GC(垃圾回收机制),因此程序员无需关心空间释放的问题,因此jvm中也只有一个堆,是被线程共享的区域
[5] 方法区(Method Area) --> 也是线程共享的区域,用来存储每个类的具体信息(类的名称,方法信息,字段信息),静态变量,常量以及编译器编译后的代码等....
常量池 : 用来存储编译期间生成的字面量和符号引用
关系 :
java栈为执行java运行程序服务-->内含存储变量
本地方法栈为执行本地程序服务
程序计数器为指示执行哪条指令的
堆用来存储存储java对象本身和数组的是,共享区域
方法区形同逻辑堆,也可叫永久代,用来存储java对象的详细信息的,也是共享区域
小结 :
1. 包与包之间产生关系 : 逐级存放,分层管理2. > 指数据重定向 ,例子 dir > d:1.txt -- > 意思是将当前文件目录名放入d盘下的1.txt文件中,若1.txt文件没有则自动创建
3. java所有的自带工具类都在lib-->tools.jar中
4. jdk下的src.zip内含java所有的源文件
5 .静态代码块-->类一加载就会执行的区域
6 : native --> 声明为本地方法,调用本地的功能,也就是一个java调用非java代码的接口
1050
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
