Java SE 学习笔记 (javaDoc,构造代码块,面向接口编程,抽象类,多态,内部类,异常)

Java Doc 文档的制作：

Java Doc制作   dos命令：

　　Javadoc -d 目录 -author -version 名.java

随机数：

　　int num=(int)(Math.random()*100)+1;

构造代码块：

　　局部代码块：局部位置，用于限定变量的生命周期

　　构造代码块：在类的成员位置，用{}括起来的代码

　　静态代码块：在类中的成员位置

　　　　static{}   只执行一次

抽象类：

　　抽象类不能和那些关键字共存。

　　final,private,static。

接口：

　　

　　实现：implements  exends 继承

　　接口：interface

　　接口好处：可以多继承，用来扩展。

　　多个接口，只实现其中的一个接口

 

      问题 ： 因为实现接口，必须实现接口中所有的方法。那么一个接口中有多个方法，那么如何才能只实现其中的一个方法呢？

　　接口 Inter：

　　interface Inter{

　　

　　　　void show1();

　　　　void show2();

　　　　void show3();

　　}

　　解决方案：

　　　　abstract class Demo implements Inter{

　　　　　　void show1();

　　　　　　void show2();

　　　　　　void show3();

　　　　}

 

　　　　public class Test extends Demo{

　　　　　　@Overide

　　　　　　public void show1(){

　　　　　　　　syso("HelloWorld");

　　　　　　}

　　　　}

　　　　面向接口编程的思想：

　　　　　　类用于描述事物的共性，基本功能。

　　　　　　接口用于定义的都是事物的额外功能

       　　

　　　　抽象类和接口的区别：

　　　　1:　　类与类是继承关系   is  a

　　　　　　类与接口是实现关系   like a

　　　　

　　　　2:　抽象类中可以定义抽象和非抽象方法，子类可以直接使用或者覆盖作用。

　　　　　　接口中定义的都是抽象方法。必须实现才能使用

　　　　　　public static final

 

　　　　多态：

　　　　　多态在程序中的体现： 父类的引用或者接口的引用指向了子类的对象。

　　　　　多态的好处：提高了代码的复用性

　　　　　多态的弊端：不能使用子类特有的方法

　　　　　　1.　多态中的  成员变量：

　　　　　　　　　当子父类中出现同名成员变量时。多态调用，只看调用该成员变量所引用所属类中的成员变量。

　　　　　　　　　无论编译或运行，只看等号左边的。

　　　　　　2.　多态中的 成员函数：

　　　　　　　　　出现一模一样的函数时，多态调用

　　　　　　　　　编译时：看的是引用变量所属类中的方法

　　　　　　　　　运行时：看的是对象所属类中的方法

　　　　　　　　　简单说： 编译看左边，运行看右边

　　　　　　3.   静态函数

　　　　　　　　编译运行都看左边

　　　　Java 内部类：

　　　　　　非静态，非私有的访问方式：

　　　　　　语法：  Outer.Inner  in=new Outer().new Inner();

　　　　　　静态内部类：  访问方式，访问非静态成员

　　　　　　Outer.Inner in=new Outer.Inner2();

　　　　　　　　in.show2();

　　　　　　静态，非私有的内部类访问静态成员：

　　　　　　class Test{

　　　　　　　　class Inner{

　　　　　　　　　　static final int cout=5;

　　　　　　　　}

　　　　　　}

　　　　Java中局部类内部类    不允许直接访问所在局部的局部变量。如果加了final，编译后就变为5.

　　　　只能访问被final修饰的常量

　　

　　　　匿名内部类：

　　　　　　语法：public void method(){

　　　　　　　　　　new Demo(){

　　　　　　　　　　　　public void show(){

　　　　　　　　　　　　　　System.out.println("show...");

　　　　　　　　　　　　}

　　　　　　　　　　}

　　　　　　　　　}

　　　　主函数访问类：

　　　　　　class InnerClassDemo(){

　　　　　　　　public static void main(String[] args){

　　　　　　　　　　new InnerClassDemo().new Inner();

　　　　　　　　}

　　　　　　}

　　　　　　class Inner{   // 主函数访问Inner,要么new对象 要么加上static

　　　　　　}

　　　　　　public void show(){　　

　　　　　　　　new Inner();

　　　　　　}

　　　　

　　　　Java 异常处理

　　　　问题分为两种：

　　　　　Throwable: 定义了对于问题的共性功能。

　　　　　-- Error: 由系统底层发生的，告诉JVM,JVM告诉使用者。

　　　　　不做针对性的处理：

　　　　　-- Exception: JVM 发生，并告诉给使用者。可以进行针对性的处理

　　　　　e.getMessage();   // 异常信息

　　　　　e.toString();        // 异常名称+异常信息

　　　　　e.printStackTrace();  //名字+信息+位置

　　　　　

　　　　　异常的声明与抛出：

　　　　　　int div(int a,int b)throws Exception{

　　　　　　　　if(b==0)

　　　　　　　　　　throw new AritheticException("除零了");

　　　　　　　　return a/b;

　　　　　　}

　　　　 throw 和throws有什么区别：

　　　　　　1.位置不同

　　　　　　　　throws 用在函数上，后面跟的是异常类，可以跟多个

　　　　　　      throw 用在函数内，后面跟的是异常的对象

　　　　　　2.功能不同。

　　　　　　　　throws: 用来声明异常，让调用者只知道该功能可能出现的问题，并由调用者可以给出预先的处理方式

　　　　　　　　throw: 用来抛出具体的问题对象。执行到throw功能就已经结束了，跳转到调用者。并将具体问题对象也抛给调用者

　　　　　　　　throw 语句独立存在时，下面不要定义其他语句

　　　　　　Exception 异常分两个：

　　　　　　　　运行时异常： runtimeException

　　　　　　　　编译时异常： CheckedException

　　　　　　自定义异常：

　　　　　　　　例：定义一个功能实现除法运算，但除数不能为负数

　　　　　　　　class FuShuException extends RuntimeException{   //自定义函数继承了运行时的异常超类

　　　　　　　　　　FuShuException(String Message){

　　　　　　　　　　　　supper(Message);

　　　　　　　　　　}

　　　　　　　　}

　　　　　　　　class Demo{

　　　　　　　　　　int div(int a,int b){

　　　　　　　　　　　　if(b<0)

　　　　　　　　　　　　　　throw new FuShuException("负数不能为整数");

　　　　　　　　　　　　if(b==0)

　　　　　　　　　　　　　　throw ne ArithmeticException("被零除了");

　　　　　　　　　　　　return a/b;

　　　　　　　　　　}

　　　　　　　　}

　　　　　　　　class Test{

　　　　　　　　　　public static void main(){

　　　　　　　　　　　　　　.....

　　　　　　　　　　}

　　　　　　　　}