java 权限关键字
private:私有，是一个权限修饰符。用于修饰成员，私有的内容只在本类中有效。
public：公共所有的对象都可以引用。
class de{ int x = 3; public static void main(String[] args) { de d = new de(); System.out.println(d.x); d.x = 9; System.out.println(d.x); show(d); System.out.println(d.x); } public static void show(de d) { d.x = 4; }} 结果为 ；
3 第一个为引用为类中的成员变量；
9 第二个对成员变量重新赋值
4 第三个地址变化，由堆地址变为栈地址
javadoc提取信息的格式 javadoc -private -d doc -author -version myHelloworld.java
/**建立一个用于操作数组的工具类，其中包含着常见的对数组操作的函数如：最值，排序等 。@author 张三@version V1.0*/public class ArrayTool{ /** 获取整型数组的最大值。 @param arr 接收一个元素为int类型的数组。 @return 该数组的最大的元素值 */ public static int getMax(int[] arr) { int maxIndex = 0; for(int x=1; x arr[maxIndex]) maxIndex = x;// } return arr[maxIndex]; } } 子类可以继承和覆盖父类
覆盖注意事项：
1，子类方法覆盖父类方法时，子类权限必须要大于等于父类的权限。
2，静态只能覆盖静态，或被静态覆盖。
抽象类
特点：
1，方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰。
抽象方法必须定义在抽象类中。该类必须也被abstract修饰。
2，抽象类不可以被实例化。为什么？因为调用抽象方法没意义。
3，抽象类必须在其子类覆盖了所有的抽象方法后，该子类才可以实例化。否则，这个子类还是抽象类。
1，抽象类中有构造函数吗？
有，用于给子类对象进行初始化。
2，抽象类可以不定义抽象方法吗？
可以的。 但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。
通常这个类中的方法有方法体，但是却没有内容。
abstract class Demo{ Demo() { System.out.println("demoa "); } abstract /*抽象*/ void show(); void ha() { System.out.println("demoa s"); } }class DemoA extends Demo{ void show() //覆盖虚拟类show { System.out.println("demoa show"); }}class AS{ public static void main(String[] args) { DemoA a = new DemoA(); a.show(); a.ha(); //虚拟类中的非虚拟方法可以直接用 }}结果 demoa //虚拟类的构造函数 demoa show demoa s 3，抽象关键字不可以和那些关键字共存?
private不行 static不行 final不行 因为虚拟类需要被子类覆盖
4，抽象类和一般类的异同点。
相同点：
抽象类和一般类都是用来描述事物的，都在内部定了成员。
不同：
1，一般类有足够的信息描述事物。
抽象类描述事物的信息有可能不足。
2，一般类中不能定义抽象方法，只能定非抽象方法。
抽象类中可定义抽象方法，同时也可以定义非抽象方法。
3，一般类可以被实例化。
抽象类不可以被实例化。
5，抽象类一定是个父类吗？
是的。因为需要子类覆盖其方法后才可以对子类实例化。
接口
当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用
另一种形式定义和表示，就是 接口 interface。
对于接口当中常见的成员：而且这些成员都有固定的修饰符。
1，全局常量: public static final
2，抽象方法。public abstract
由此得出结论，接口中的成员都是公共的权限.
interface Demo{ public static final int NUM = 4; public abstract void show1(); public abstract void show2();}class DemoImpl implements /*实现*/Demo{ public void show1() {} public void show2() { }} 类与类之间是继承关系，类与接口直接是实现关系。
接口不可以实例化。只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。
java中不直接支持多继承，一个类可以实现多个接口，接口的出现避免了单继承的局限性。
interface A{ public void show();}interface Z{ public int add(int a,int b);}class Test implements A,Z//多实现{ public int add(int a,int b) { return a+b; } public void show(){}} 一个类在继承另一个类的同时，还可以实现多个接口。
class Q{ public void method() {}}abstract class Test2 extends Q implements A,Z{} 接口可以多继承
interface CC{ void show();}interface MM{ void method();}interface QQ extends CC,MM//接口与接口之间是继承关系，而且接口可以多继承。 { void function();}class WW implements QQ{//覆盖3个方法。 public void show(){} public void method(){} public void function(){}} 接口与抽象类不同点：
1，抽象类需要被继承，而且只能单继承。
接口需要被实现，而且可以多实现。
2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
接口中只能定义抽象方法，必须由子类去实现。
多态
class 动物{}class 猫 extends 动物{} 动物 x = new 猫();//一个对象，两种形态。
猫这类事物即具备者猫的形态，又具备着动物的形态。这就是对象的多态性。
父类或者接口的引用指向其子类的对象。
多态的好处：
提高了代码的扩展性，前期定义的代码可以使用后期的内容。
多态的弊端：
前期定义的内容不能使用(调用)后期子类的特有内容。
多态的前提：
1，必须有关系，继承，实现。
2，要有覆盖。
class Fu{ int num = 3; void show() { System.out.println("fu show"); } static void method() { System.out.println("fu static method"); }}class Zi extends Fu{ int num = 4; void show() { System.out.println("zi show"); } static void method() { System.out.println("zi static method"); }}class DuoTaiDemo3{ public static void main(String[] args) { Fu f = new Zi(); f.method(); //fu static method 静态函数 看左边 f.show(); //zi show 成员函数非静态 看右边 System.out.println(f.num); //3 成员函数 看左边 }}
多态时，成员的特点：
1，成员变量。编译和运行都参考等号的左边
2，成员函数(非静态)。编译看左边，运行看右边
3，静态函数。编译和运行都看左边。
内部类
class Outer{ int num = 3; class Inner { int num = 4; void show() { int num = 5; System.out.println(Outer.this.num); } } void method() { new Inner().show(); }}class InnerClassDemo2 { public static void main(String[] args) { new Outer().method(); new Outer().new Inner().show(); //直接引用内部类 }}System.out.println(Outer.this.num); //结果为 3//去掉Outer. 结果为 4//去掉this. 结果为5 异常
throws 和throw的区别。
1，throws使用在函数上。
throw使用在函数内。
2，throws抛出的是异常类，可以抛出多个，用逗号隔开。
throw抛出的是异常对象。
try{ //需要被检测异常的代码。}catch(异常类 变量)//该变量用于接收发生的异常对象{ //处理异常的代码。}finally{ //一定会被执行的代码。}如果catch中有return，则不会执行到这里，而finally中的内容会被执行 class Demo{ public int method(int[] arr,int index) throws NullPointerException { if(arr==null) throw new NullPointerException("没有任何数组实体"); if(index<0) throw new FuShuIndexException(); return arr[index]; }}class ExceptionDemo4{ public static void main(String[] args) { int[] arr = new int[3]; Demo d = new Demo(); try { int num = d.method(null,-1); //调用method方法，可能会产生异常 System.out.println("num="+num); } catch(NullPointerException e) { System.out.println(e.toString()); } System.out.println("over"); } } package myclass 生成类放 myclass目录下import myclass.*; 导入myclass类
正在进行的程序为进程：应用程序对应的在内存中的空间，进程 不运行，只是分配内存空间
线程是：进程中 执行路径 决定在内存中走那些内存
创建线程步骤：
1，定义一个类继承Thread类。
2，覆盖Thread类中的run方法。
3，直接创建Thread的子类对象创建线程。
4，调用start方法开启线程并调用线程的任务run方法执行。
class Demo extends Thread{ public void run() { for(int x=0; x<10; x++) { for(int y=-9999999; y<999999999; y++){} //加点延时为了体现线程 System.out.println(name+" x="+x+" name="+Thread.currentThread().getName()); } }}class ThreadDemo2 { public static void main(String[] args) { Demo d1 = new Demo(); Demo d2 = new Demo(); d1.start();//开启线程，调用run方法。 d2.start(); }} 1,定义类实现Runnable接口。
2，覆盖接口中的run方法，将线程的任务代码封装到run方法中。
3，通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。
class Demo implements Runnable//extends Fu //准备扩展Demo类的功能，让其中的内容可以作为线程的任务执行。 //通过接口的形式完成。{ public void run() { show(); } public void show() { for(int x=0; x<20; x++) { System.out.println(Thread.currentThread().getName()+"....."+x); } }}class ThreadDemo{ public static void main(String[] args) { Demo d = new Demo(); Thread t1 = new Thread(d); Thread t2 = new Thread(d); t1.start(); t2.start(); }}