新手热门JAVA_其它编程-织梦者
当前位置:&>&&>& > 新手热门JAVA
新手热门JAVA
学习方法：
1、记笔记。
2、代码加注释
=============================================day1============================================
一、Java简介：
1、Java是一门程序设计语言。
（程序设计语言）
2、Java历史：
1）1990年底Sun公司Green项目组，JamesGosling詹姆斯高斯林
2）1992年Oak语言诞生
3）1993年第一次投标失败
4）1994年Oak改名为Java，在互联网行业的冲击下，被业界所认可。
5）日Sun公司正式发布Java1.0
6）日被Oracle收购，市值74亿。
3、Java语言特点：
1）纯面面向对象
2）简单性PKc++
4、Java语言运行机制：
源文件（.java）----&编译器-----&字节码文件（.class）----&JVM----&解释器----&CPU运行
二、Java开发前准备
1、搭建环境：
1）JRE（JavaRuntimeEnvironment）：Java运行环境，包含JVM，解释器。
2）JDK（JavaDevelopementKit）：Java开发工具包，包含JRE、类库、工具、编译器等。
2、安装JDK：
*安装目录不允许出现中文
3、配置环境变量
右键计算机----&属性----&高级系统设置---&环境变量--在系统变量中新建环境变量。
JAVA_HOME：JDK安装目录
(修改)path:%JAVA_HOME%\bin
ClassPath:.
三、第一个Java程序（HelloWorld）
1、新建源文件：xxxx.java2、在源文件中进行编码
关键字类名
publicclassHelloWorld{
主函数（程序的入口函数）
publicstaticvoidmain(Stringargs[]){
向控制台输出一句话：你吃了吗？
System.out.println(&你吃了吗？&);
3、将.java文件编译成.class文件
javac文件名.java
4、执行.class文件
1.publicclass类名：代表公开类，公开类的类名要与文件名一致，一个源文件中只能有一个公开类。
2.class类名：非公开类，允许类名与文件名不一致，一个源文件中可以有多个非公开类。
3.先编译：javac文件名.java
后解释运行：java类名
四、包（package）：指定源文件编译后的.class文件保存在哪一个文件夹下
1、package包名，放在代码的第一行。
2、编译时使用javac-d.文件名.java
3、运行时使用java包名.类名
4、引入包import包名;
多包import包名.包名.......;
import包名.*;引入该包下的所有内容
五、注释：一段描述性文字，增加代码可读性，不参与编译过程。
1、单行注释：//注释文字
2、多行注释：/*注释文字*/
3、javadoc：/**注释文字*/
六、标识符：Java中各个组件的命名规则
1、语法：由数字、字母、下划线、$组成，数字不能开头。
2、编程习惯：望文知意
1）包名：全小写例：helloworld
2）类名：单词首字母大写例：HelloWorld
3）变量名、函数名：驼峰命名例：helloWorld
4）常量名：全大写例：HELLO_WORLD
七、变量：
1、变量是JVM内存当中的一块空间，用于保存数据。
2、变量类型：
1）基本类型：
类型占用空间数据范围例
byte1b-2^7--2^7-1byteb=1;
short2b-2^15--2^15-1shorts=100;
int4b-2^31--2^31-1inti=200;
long8b-2^63--2^63-1longl=300L;
float4bfloatf=0.35F;
double8bdoubled=0.8;
booleantrue|falsebooleanbb=
char2b任何字符charc='A';
charc1=79;
2）对象类型：
String字符串自面值：&HelloWorld&
3、使用变量
1）变量的声明：
声明一个int类型的变量，变量名为a
S声明一个String类型的变量，变量名为str
2）变量的赋值：
a=10;给变量a赋值为10
3）声明同时赋值
4、局部变量：
1）定义在函数内部的变量
2）重合范围内变量名不允许重复
3）必须先赋值后使用
4）局部变量的使用范围，在定义它的代码块开始，到代码块结束。
八、运算符&表达式
1、数学运算符：+-*/%（求余） ++--
1）a+b-----&12
2）a-b-----&8
3）a*b-----&20
4）a/b-----&5
5）a%b-----&0
6）a++、++a------&a的值为11(a=a+1)
7）a--、--a------&a的值为9(a=a-1)
2、赋值运算符：=+=-=/=*=%=
1）a=b-----&把b的值赋给a
2）a+=b-----&把a+b的值赋给a（a=a+b）
3）a-=b-----&a的值为8（a=a-b）
4）a/=b-----&a的值为5
5）a*=b-----&a的值为20
6）a%=b-----&a的值为0
3、逻辑运算符：&&==&&||!
运算出的结果全部为boolean类型
1）a大于10并且小于b
a&10&&a&b-----&false
2）a等于10并且大于b
a==10&&a&b----&true
3）a不等于10
a!=10----&false
4）结果取反
!(a==10)-----false
4、三目运算符
（布尔表达式）?表达式1:表达式2;
intx=a&b?10:300;
当布尔表达式为true时结果为表达式1，反之结果为表达式2
5、强制类型转换
当较大数据类型给较小数据类型赋值时，会出现丢失精度的错误，此时需要强制类型转换
语法：doubleb=20.8;
inta=(int)b;
==================================day2=================================================
*Scanner可以让用户从控制台输入一个数字或字符，输入的字符会为程序中的一个变量赋值。
使用步骤：1、引入包：importjava.util.S
2、创建Scanner:
Scannersc=newScanner(System.in);
System.out.println(&请您输入两个整数：&);
inti=sc.nextInt();--从控制台接收一个int类型的值
doubleb=sc.nextDouble();--从控制台接收一个double类型的值
Stringstr=sc.next();--从控制台接收一个字符串
===============================================================================
一、流程控制
语法：if(布尔表达式){
当布尔表达式为true时，执行该内容
2、if-elseif
语法：if(布尔表达式){
}elseif(布尔表达式){
当不满足if条件时判断elseif中的表达式是否为真
3、if-elseif-else
语法：if(布尔表达式){
}elseif(布尔表达式){
语法：switch(整形变量|整形表达式){
case值1:要执行的代码;
case值2：要执行的代码;
default:都不满足时执行的代码;
*整形变量包括：charbyteshortint
jdk7.0以后支持String
=========================day2PM===================
定义：重复且有规律的做一件事情
三要素：循环初值循环结束条件循环递增量
一、while循环
语法：while(布尔表达式){
//循环体语句
当布尔表达式为true的时候，则执行循环体语句，执行完后再判断布尔表达式是否为true；
如果为false，则跳出循环，执行后面的语句。
1.打印100遍HelloWorld
注意：缺少循环递增量会造成死循环。
2.计算100以内的偶数的个数。
3.输入一个整数，判断它是几位数？
二、do...while循环
//循环体语句
}while(布尔表达式);
先执行循环体语句，再判断布尔表达式是否为true，如果为true，则再次执行循环体语句。
如果布尔表达书为false，跳出循环，继续执行下面的语句。
三、for循环
语法：for(初值;循环结束条件;循环递增量){
//循环体语句
先附初值，判断循环结束条件，如果条件为true，则执行循环体语句，执行完循环体语句后，
再执行循环递增量，再判断循环结束条件，如果为false，则跳出循环，继续往下执行。
小结：1.while先判断，再执行。0-多次。
do...while先执行，后判断。1-多次。
2.for,知道执行多少次的情况。
次数未知的情况，用while/do...while
四、循环控制语句
//跳出整个循环,可以跳出死循环！
//跳出本次循环
五.循环嵌套
//循环体语句
1.打印一个99乘法表
2.打印一个三角形
=======================================day3===============================
一、函数的作用：
1、减少冗余代码
2、提高程序复用性
3、方便维护
二、语法：
1、声明函数：
publicstatic返回值类型函数名(参数表)
1）参数表：函数中一个有效的局部变量，是函数的入口
参数表中可以定义多个形参，要求调用者使用该函数时，传递形参类型相同的字面值。
定义多个参数：(Stringstr,inta)
(Strings,intb,doublec,doubled.......)
*注意调用函数时，传递的数据类型、个数、位置需要全部匹配
2）返回值类型：8种基本类型，对象类型。
*一个函数如果是非void返回值类型，那么这个函数就必须return一个结果。
3）函数返回结果：return返回值;
*返回值的类型要与返回值类型相同。
4）控制void函数执行流程：
2、函数实现：
3、使用函数：
函数名(参数表);
4、函数的递归
=============================day4AM============================
是一个对象类型（引用类型）；
代表一块连续的内存空间，用于存储相同类型的数据。
注意：连续相同类型数组的长度不可变
一、数组的定义
1.数组的声明
数据类型[]变量名;
int[]a;//声明数组
a=newint[5];//给数组分配空间，定义长度为5、
int[]a=newint[5];
int[]a={1,4,5,2};//声明数组，给数组赋值。
int[]a=newint[]{1,4,2,6};//声明数组，根据{}中数组的个数，分配空间、
1）显示初始化，要和声明数组一起进行。
2）int[]a=newint[]{1,4,2,6},[]中不能指定大小。
2。默认值
数值类型：0或者0.0
布尔类型：false
char类型：'\u0000'或者''空字符
String类型：null
注意：数组下标越界异常；
二.数组的使用
范围：0~数组的长度-1
2.遍历(重点)
for(inti=0;i&a.i++){
System.out.print(a[i]+&&);
System.out.println();
三、数组的扩容
思想：重新定义一个数组，把原有数组的值赋值给新数组。
for(inti=0;i&arr.i++){
b[i]=arr[i];
2.API的方法
System.arraycopy(原数组,原数组的起始下标,新数组,新数组的起始下标,长度);
=====================day4PM===================
四.二维数组
一维数组的数组
int[][]a=newint[3][2];
二维数组中第一个[]控制的高纬长度（必须写）
二维数组中第二个[]控制的低纬长度（可以不写）
int[][]a={{1,2,3},{4,5,6},{7,8,9}};
1.冒泡排序
排序思想（以从小到大排序为例）：两个相邻的数比大小，
大的放在前面，小的放在后面,每一次冒泡都会产生一个最大的数。
2.，选择排序
排序思想（以从小到大排序为例）：每一次选择出一个最小的元素，
放到序列的起始位置，然后依次从后面选择最小的元素，往后排；
3.java.util.Arrays.sort(a);
=========================================day5========================================
一、什么是面向对象思想？
1、面向过程编程思想：自顶向下，逐步求精。
2、面向对象编程思想：从客观世界出发。
二、什么是对象？
1、一切客观存在的事物都是对象。
2、对象：属性有什么
方法能干什么
3、对象的属性有可能是另一个对象。
4、对象调用另外一个对象的方法，完成某些功能。
三、计算机中的对象代表了客观世界的对象。
计算机中的对象就是一组不可分割的数据，保存在JVM中。
四、使用面向对象思想，解决客观问题？
1、找到能够解决问题的对象
2、对象间相互配合
五、面向对象的优势：
各司其职：对象应该保持简单，由简单的对象组成复杂的系统。
弱耦合性：对象与对象之间的联系应该保持弱耦合。
可重用性：对象可以重复使用
可扩展性：再原有对象的基础上，扩展出新的对象。
六、类：对象的模板，人对客观事物的抽象。
关键字class类名
1、属性：实例变量|成员变量|全局变量
1）定义位置，类的里面方法的外面。
2）有默认值（0falsenull）
3）作用范围至少是全类内部
4）允许实例变量与局部变量命名冲突，使用时局部变量优先。
1）方法声明：（能做什么）
修饰符返回值类型函数名(参数表)抛出的异常
2）方法的实现（怎么做）
3）方法的重载（Overloading）一个类中，可以有多个重名的方法，从参数表数量、类型、位置上区分。
函数名相同，参数表不同，返回值无要求。
参数表不同：数量
七、创建对象：
1、语法：类名引用名=new类名();
例：Studentstu=newStudent();
2、对象是JVM中的一块内存空间
八、使用对象：
1、使用属性：
1）访问属性：引用名.属性名;
2）设置属性：引用名.属性名=值;
2、使用方法：
引用名.方法名(参数);
九、构造方法（构造器）
1、方法名和类名相同
2、没有返回值类型
3、不允许手工调用，只会在对象构造过程中自动调用一次。
1、this.属性名：使用当前对象属性，区分局部变量和成员变量。
this.方法名：使用当前对象的方法。
2、this()：调用本类的其他构造方法，必须出现在构造方法的第一行。
十一、创建对象的过程：
1、分配空间属性被赋予默认值(nullfalse00.0)
2、初始化属性属性被赋予初始值(属性：Stringname=&张三&;)
3、调用构造方法属性被赋予构造参数
十二、java中数据的传递规则
1、简单类型传值
2、对象类型传引用（地址）
==========================================day6===================================================
面向对象三大特性
封装：明确对象的边界，由边界起到保护内部属性的作用。
数据隐藏：
一、修饰符：public公开的，随意获取，随意设置
private私有的，只能本类使用
二、提供get/set：get方法用于获取属性
set方法用于设置属性
三、封装步骤：
1.属性私有
2.提供公开的get、set方法
=======================================day6pm=======================================
从父类--子类一般----特殊
子类可以继承子类可调用的方法。
一、访问权限修饰符：
关键字使用范围能否被继承
private本类内部不能
(default)本类+同包同包子类可以继承
protected本类+同包+子类可以继承
public所有可以继承
二、方法覆盖（Override）
1.作用：子类用特殊的方法实现，替换掉父类继承给它的一般实现。
2.语法：方法名、返回值类型、参数表一致，访问权限修饰符相同或更宽。
super.访问父类被覆盖的属性或方法
super()调用父类哪个构造方法，写在子类构造方法的第一行
四、对象的创建过程：
1.分配空间，属性被赋予默认值。
2.构造父类对象。
3.初始化本类属性，属性被赋予初始值。
4.调用本类构造方法。
C----B-----A
初始化A类属性
调用A类构造方法
初始化B类属性
调用B类构造方法
初始化C类属性
调用C类构造方法
**Java中继承关系为单继承，每个类只允许有一个父类。
一个父类可以有多个子类。
==================================day7==========================================
子类的对象可以看作是父类的对象，子类是特殊的父类。
子类对象可以放入父类引用。
例如：Animala=newDog();Dog是Animal的子类
1.对象类型不变
2.只能对引用调用其引用类型中声明的方法
3.运行时，会根据对象实际类型找子类覆盖后的方法
子类引用赋值给父类引用可以直接赋值
Dogd=newDog();
Animala=d;
父类引用赋值给子类引用必须强制类型
转换保证编译通过，运行时可能产生类型转换异常。
Animala=newDog();
Dogd=(Dog)a;
引用instanceof类名值为boolean类型
判断引用中保存的对象是什么类型
多态使得程序变得更通用，说话、办事越是针对父类越通用。
多态能够屏蔽众多子类之间的差异，使得程序更加灵活。
多态用在方法参数上：
m(Aa)：形参可以是父类类型，实参为形参的子类。
多态用在方法返回值上：
Am()：m方法完全可以返回一个A的子类对象。
=================三大修饰符===============
static、final、abstract
一、static（静态）
1.属性（实例变量）
static修饰的属性称为静态属性，也叫类变量。
语法：static访问修饰符类型变量名；
特点：static修饰的属性被所有对象共享（与对象无关）
使用：1）new对象
对象名.属性；
2）类名.属性（建议使用）
static修饰的方法称为静态方法，也叫类方法；
语法:static访问修饰符返回值类型方法名（形参列表）{}
1)对象名.方法名；
2）类名.方法名；（建议使用）
注意：1）static方法中不能使用this或者super
2)静态的方法不能直接调用非静态的方法，可以直接调用静态的方法。
静态的方法可以简介调用非静态的方法（使用new对象的方法）。
3）static方法可以被覆盖，但是static方法，只能覆盖static方法，但是没有多态。
4）引用被覆盖的static方法时，引用本身的方法会被执行。
3.初始代码块
定义位置：类以内，方法以外。
初始代码块：用于创建对象时候，按照定义的顺序进行初始化工作。
static修饰的初始化代码块，称为静态初始化代码块。
静态初始化代码块：用于类加载的时候，按照定义的顺序进行初始化工作。
定义：当JVM第一次运行某个类时，会提前在classpath路径下，找到这个类所对应的class文件，
并进行类的读取，获取到这个类的相关信息（属性，方法。返回值类型...）,
把相关的类信息保存在内存中，类加载只进行一次；
类加载的时机：
1）创建对象时，进行类加载；
2）调用该类静态成员（属性。方法）时，进行类加载。
3）创建子类对象的时候，也进行类加载。
二。final（最终的）
1.变量（局部变量，类变量，实例变量）
final修饰的变量，称为最终变量，只能赋值一次，且不可修改
1）final修饰的实例变量，不再提供默认值，
会在声明或者构造方法中进行赋值。
若果再构造方法里赋值，所有构造方法中都必须赋值。
2）final修饰类变量。不再提供默认值、
会在声明或者静态初始化代码块中进行赋值。
final修饰的方法为最终方法，可以被继承，不能被覆盖。
final修饰类，为最终类，不能被继承。
三、abstract（抽象）不完整
抽象方法：只有声明，没有实现（意味着{}都没有）。
publicvoidxxx();
抽象类，不能实例化。
1）抽象类，不能创建对象。但是可以声明引用。
2）子类继承抽象类，必须实现父类中所有的抽象方法，除非子类还是抽象的。
3）抽象类中，可以有抽象的方法，也可以非抽象的方法。
4)有构造方法，当子类对象创建时，调用
特点：强制使用多态。
==================================================================
接口:interface
特殊的抽象类:
不完整的类
方法：所有的方法公开抽象方法;publicabstract可省略
属性：所有的属性都是公开静态的常量;publicstaticfinal可省略
构造方法:没有
interfaceIA{
publicstaticfinalintAGE=0;//常量名:全部大写
publicabstractvoidmethod();//
声明接口语法:
对比:abstractclassMyClass{
//一般方法
//抽象方法
interfaceMyInterface{
实现类使用接口
classXxxximplements接口{
*接口有抽象方法，实现抽象方法；
*一个类可以extends父类同时还能实现implements多个接口
classCaextendsSuperClassimplementsIA,IB,IC{
//将IA,IB,IC接口中方法全部实现
【定义标准】
将标准的[实现者]和标准的使用者分离;
[变相实现多继承]
一个类可以实现多个接口同时继承一个父类
//造一个灯泡，造台灯，用台灯点亮灯泡;
问题:一种台灯只能点亮一种灯泡?
1.将所有灯泡的接口统一标准:
2.设计台灯，符合灯泡的标准;
制定标准-----弱耦合
11题，17题(思考)
=========================内部类======================
定义：定义在一个类的内部的类
是编译时的一个概念，编译后会产生相应的.class
1.成员内部类
相当于成员变量，定义在类以内，方法以外。
1）成员内部类创建对象时，先创建外部类的对象，再外部类对象的基础上创建内部类对象。
Outero1=newOuter();
Outer.Innerin=o1.newInner();
2）this.当前对象的成员。想用父类的属性；外部类类名.this来调用。
3）成员内部类中不能定义static成员，
原因（内部类创建对象必须依托于外部类的对象，static是与对象无关的，矛盾了！）
特点：不破坏封装的前提下，使用外部类的私有属性。
2.静态内部类
相当于类变量，定义在类以内，方法以外。
1）创建内部类对象时，不需要先创建外部类对象，可以直接创建内部类对象、
Outer.Innerin=newOuter.Inner();
2）静态内部类中，只能调用外部静态的成员。
3）静态内部类中定义的变量与外部类定义的变量重名时，
可以用类名.成员调用外部类成员。
3.局部内部类
相当于局部变量，定义在方法以内。
1）局部内部类，和局部变量的作用范围是一样。
2）局部内部类创建对象时，必须在它的作用范围内；
Innerin=newInner();
3）局部内部类，要想使用外部类方法中的属性，必须定义为final的。
4.匿名内部类
特殊的内部类。
1）只创建一个对象。
2）这个必须从父类/父接口中进行继承/实现
returnnewAnimal(){
publicvoideat(){
System.out.println(&========够吃骨头======&);
父类/父接口应用名=newAnimal(){
publicvoideat(){
System.out.println(&========够吃骨头======&);
=======================集合（II）===================
泛型集合：强制集合中的类型必须统一。
为了防止类型转换异常。
工具类（Collections）：提供了一些对集合/数组的一些简单操作：排序。
publicstaticvoidreverse(List&?&list)//进行倒序
publicstaticvoidshuffle(List&?&list)//随机产生顺序
publicstaticvoidsort(List&T&list)//按照一定的规则进行排序
需要排序规则
lang包中的规则：Comparable接口
实现compareTo方法；
//比较this和指定对象stu的大小
//this&stu返回&0
//this&stu返回&0
//this==stu返回=0
publicintcompareTo(Studentstu){
if(this.age&stu.age)
elseif(this.age&stu.age)
三、set接口
元素无顺序，无下标，不可以重复。
从Collection继承来的所有方法。
1）HashSet
如果要实现HashSet中元素的值不重复。
1，覆盖HashCode
确保相同的对象返回相同的int值（HsahCode值）
为了提高效率，尽量做到不同的对象返回不同的int值。
通常把对象的属性值加到一起，如果是对象类型调用该对象的HashCode方法。
2.覆盖equals
当在同一位置上已经存在集合元素时，会再调用equals方法，判断2个对象的内容是否相同，
如果相同则拒绝加入集合。
2）TreeSet
实现了SortedSet接口，也是Set的子接口
自动进行排序。
排重：实现parable接口,实现接口中的方法compareTo方法。如果返回值0，重复了就不会添加。
四、Map接口
存放任意的键值对（Key----Value）。
键：无序，无下标，元素不可重复。（键是唯一的）
值：无序，无下标，元素可以重复。
Vput(Kkey,Vvalue)//往map中添加一个元素，假如键已经存在，会覆盖原有的值
Vremove(Objectkey)//根据键删除对应的键值对。
Vget(Objectkey)//根据键获得对应的值。
booleancontainsKey(Objectkey)//判断Map集合中是否包含指定的键。
booleancontainsValue(Objectvalue)//判断Map中是否包含指定的值。
Set&K&keySet()
2.值遍历
Collection&V&values()
3.键值对
Set&Map.Entry&K,V&&entrySet()
1）hashMap（假如键为自定义类型，需要覆盖hashCode和equals方法，保证键唯一）
jdk1.2线程不安全，快
允许key和value都为null
2)hashTable
jdk1.0线程安全，慢
允许key和value都不为null
3)Properties
是hashTable的一个子类，要求key和value必须都为String类型。
多数用于读取配置文件。
实现了SortedMap接口，是Map的子类。会根据键进行排序。
实现Compareble接口，实现里面的compareTo方法。返回值是0，覆盖了原有的值。
Collection
有下标无下标
可以重复不可重复
键值对
键：无序，无下标，不可重复（键唯一）
值：无序，无下标，可以重复
LinkedList和ArrayList的区别？
链表查询慢，增删快
数组查询快，增删慢
ArrayList和Vector的区别？
1.2线程不安全，快，轻量级
1.0线程安全，慢，重量级
HashMap和Hashtable的区别？
jdk1.2线程不安全，快
允许key和value都为null
jdk1.0线程安全，慢
允许key和value都不为null
Hashtable和Properties的区别？
泛型集合的好处？
数据安全。强制集合中的类型必须统一
HashSet和TreeSet分别如何实现元素不重复？
Collection和Collections的区别？
1.下标遍历
list.add();
for(inti=0;i&list.size();i++){
2.Iterator迭代遍历
Iteratorin=list.interator();
while(in.hasNext()){
Obejecto=in.next();
3.for(Objecto:list){}
Set&K&set=map.keySet()
2.值遍历
Collection&V&con=map.values()
3.键值对遍历
Set&Map.Entry&K,V&&entrySet=map.entrySet();
========================异常==========================
异常：程序运行过程中，出现的错误，例外。
异常处理：异常发生之后，会执行一段预先写好的代码，减少损失。
一、异常分类
|-Error错误，底层代码出现严重问题，无法避免，程序员无法解决，无需程序员来解决
|-Exception异常
|-RuntimeException运行时异常/未检查异常编译时忽略可以避免可以处理也可以不处理
|-IndexOutOfBoundsException
|-NullPointerException
|-ClassCastException
|-非RuntimeException非运行时异常/已检查异常编译时会出错，必须要处理
二、异常的产生和传递
1.异常的产生
1）自动产生
程序运行时，遇到出错的代码，自动产生异常，程序自动终止。
2）手动产生
thrownew异常名称（实参）；//手动抛异常，必须定义在方法以内。
程序执行到手动抛异常，会把throw后面new的异常对象抛出，程序自动终止。
2.异常的传递
异常堆栈信息：
Exceptioninthread&main&java.lang.ArithmeticException:/byzero
atDay17.TestException.m3(TestException.java:24)
atDay17.TestException.m2(TestException.java:19)
atDay17.TestException.m1(TestException.java:14)
atDay17.TestException.main(TestException.java:9)
程序因异常终止后，会以函数的调用的反方向进行传递。
三、异常的处理【重点】
1.消极的处理（声明异常）
语法：（定义在方法声明的后面）
修饰符返回值类型方法名（形参列表）throws异常的名称1,异常的名称2...{
使用throws只是消极的把异常继续往后传递，并没有解决问题。
2.积极地处理（捕获异常）
//可能出现异常的语句
}catch(IOExceptione){
//处理异常的语句
//一定会被执行。
注意：1）try后面可以跟多个catch,但是父类异常必须放到后面。
2）catch可以捕获异常，可能出现非RuntimeException或者runtimeException
3)finally中的语句，一定会被执行。
try...catch...
try...catch...finally...
try...finally...
try...catch...catch...catch...
try...catch...catch...catch...finally...
try...(try...catch...finally...)...catch...(try...catch...finally...)...finally...(try...catch...finally...)...
消极处理和积极处理是可以使用。
四、自定义异常类
publicclassMyExceptionextendsException{
MyException(){}
MyException(Stringmsg){
super(msg);
五、方法的覆盖
1.语法要求：方法名，返回值类型，形参列表必须相同。
2.访问修饰符可同或更宽。
3.子类的方法中，不允许抛出更多、更广的异常。
=======================================线程=========================================
进程：操作系统中，并发执行的任务。
并发执行原理：宏观并行，微观串行。
线程：在一个进程中，并发执行的多个程序逻辑。
主线程：main函数。
特点：多线程中，先后顺序不确定。
不因任何线程结束而结束。
线程的组成：
1）CPU操作系统（OS）选中。
2）内存分配
栈空间局部变量独立
堆空间new对象被所有的线程所共享。
1.继承Thread父类。
覆盖run方法。
创建线程对象：MyThread1t1=newMyThread1();
启动线程：t1.start();
2.实现Runnable接口
实现run方法
创建线程对象：
//创建目标对象
Targett=newTarget();
//创建线程对象
Threadt2=newThread(t);
启动线程：
t2.start();
二、线程的状态
详情,请看线程状态图
三、线程同步/安全[重点]
临界资源：多线程并发时，共享的一个对象
原子操作：要执行的代码作为一个整体，如果执行则执行，如果不执行则不执行。
线程同步/安全：多线程并发时，为了保证临界资源的正确性，而不破坏代码的原子操作。
线程同步的2种方法：
synchronized
1)同步代码块
使用在方法内部，语法：
synchronized(临界资源对象){
//原子操作
线程只有获取到临界资源对象的锁标记，才能执行后面{}中的代码，
并且必须等{}中的所有代码都执行完，才释放该对象的锁标记。
如果没有获取到临界资源对象的锁标记，则该线程处于等待状态（锁池状态）。
直到拿到锁标记，才能执行代码块。
2)同步方法
synchronized修饰方法
synchronized返回值类型方法名(形参){
//原子操作
synchronized(this){
//原子操作
以上就是新手热门JAVA的全文介绍,希望对您学习和使用程序编程有所帮助.
这些内容可能对你也有帮助
更多可查看其它编程列表页。
猜您也会喜欢这些文章