java 继承 多态 虚拟类 接口 异常 线程 内部类

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.length; x++)
		{
			if(arr[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();
	}
}