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

最新推荐文章于 2024-07-13 13:55:40 发布

weixin_33860553

最新推荐文章于 2024-07-13 13:55:40 发布

阅读量136

点赞数

文章标签： java python

原文链接：https://my.oschina.net/u/274829/blog/296483

版权

2019独角兽企业重金招聘Python工程师标准>>>

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();
	}
}

转载于:https://my.oschina.net/u/274829/blog/296483