黑马程序员——java基础--面向对象（篇二）

最新推荐文章于 2015-12-30 14:52:22 发布

approche

最新推荐文章于 2015-12-30 14:52:22 发布

阅读量446

点赞数

分类专栏： Java基础文章标签： java exception 异常多态内部类

本文链接：https://blog.csdn.net/approche/article/details/43916741

版权

Java基础专栏收录该内容

17 篇文章 0 订阅

订阅专栏

本文深入探讨Java中的多态性，包括类型转换、核心思想及其实现步骤。接着讲解内部类的概念和设计，以及异常处理机制，包括自定义异常和异常报告的准确性。最后，文章提到了Java编程中的分层思想和子父类异常处理原则。

摘要由CSDN通过智能技术生成

------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

第一章

1、多态 2、类型转换 3、多态核心思想 4、绑定 5、接口

第二章

1、内部类 2、异常 3、异常报告不准确的问题 4、模版设计

第三章

1、分层思想 2、子父类异常

第一章

1、多态

同一事物具有多种形态，java中指对象。同一对象可以有多种引用。
函数也具有多态性：重载和覆盖。

多态的出现大大提高了程序的扩展性。
扩展性：包括体系内部的扩展和外部体系扩展。

多态十分体系内部扩展（定义接口，扩展子类）
前提：
有继承或者实现关系；
通常，还存在覆盖。
弊端：
只能使用父类的引用访问父类中存在的成员。

代码演示：

/*
继承中多态
*/
class Fu
{
	String name="fu";
}

class Zi extends Fu
{
	String name="zi";
}

class Test
{
public static void main(String[] args)	
{
  Fu o =new Zi();
  System.out.println(o.name);
}

}

2、类型转换

向上转型===类型自动提升
向下转型===强制转换（本来就是这种对象）
多态自始至终都是子类做着变化。
关键字：instanceof xx是否是yy实例的引用。

3、多态核心思想

代码向上抽取，形成大类，创建工具类，利用多态的思想，通过用工具类操作大类来操作小类，然后在main中调用工具类即可
实现步骤：
1.创建体系：大类和工具类
2.调用：主函数调用工具类

成员函数在多态调用中，编译看左边，运行看右边；

注意：成员变量在多态调用中，编译运行都看左边（？？？？多态运用中，成员变量无重写特性）；

静态成员变量在多态的调用中，编译运行都看左边（因为它是随类加载的，不依赖对象）。

代码演示：

/*
创建体系
1.创建具有基本功能的基类
2.创建操作该基类的工具类
*/
abstract class Student
{
	public abstract void study();
	public abstract void eat();
}

class StudenntTool
{
	public  void doo(Student stu){
		stu.study();
		stu.eat();
	}


}
/*
后期增加的子功能类

*/

//基础班学生
class BaseStudent extends Student
{
	public void eat()
	{
		 System.out.println("基础班的学生在吃饭");
	}

	public void study()
	{
		System.out.println("基础班的学生在学习");
	}
}
//高级班学生
class AdvStudent extends Student
{
	public void eat()
	{
		 System.out.println("高级班的学生在吃饭");
	}

	public void study()
	{
		System.out.println("高级班的学生在学习");
	}
}


class Test
{
	public static void main(String[] args)
	{
		StudenntTool st=new StudenntTool();
		st.doo(new BaseStudent() );
		st.doo(new AdvStudent() );
	}

}

4、绑定

方法区中，存在静态区和非静态区。

静态绑定：静态成员绑定在类上的；

动态绑定：非静态成员是绑定在对象上的。

5、接口

(1)总结
interface:降低耦合性，提高扩展性，定义规则；
多态：提高程序扩展性。

（2）接口设计
在编程前，一定要进行结构设计，使用好接口，牢记功能扩展。

（3）代码演示

/*
电脑的运行需要主板
在主板上需要不断的扩充功能

思路：
1。创建主板
2，在主板上预留接口，该接口可以进行多中功能的扩展
3，实现扩展功能

*/
//定义主板
class MainBoard
{
	public void run()
	{
		System.out.println("主板运行");
	}

	public void stop()
	{
		System.out.println("主板停止运行");
	}

	public void userPCI( PCI p)
	{
		
			p.open();
			p.close();
	}
}

//定义接口
interface PCI
{
	public void open();
	public void close();
}


//后期功能扩展
//接入网卡
class NetCard implements PCI
{
	public void open()
	{
		System.out.println("开启网卡");
	}
	public void close()
	{
		System.out.println("关闭网卡");
	}
}
//接入声卡
class SoundCard implements PCI
{
	public void open()
	{
		System.out.println("开启声卡");
	}
	public void close()
	{
		System.out.println("关闭声卡");
	}
}


//用电脑：
class Test
{
	public static void main(String[] args)
	{
		MainBoard mb=new MainBoard();
		mb.run();
		mb.userPCI( new NetCard() );
		mb.userPCI( new SoundCard() );
		mb.stop();
	}
}

第二章

1、内部类

（1）简介
属于类的成员，可以直接访问类的其他成员
外部类访问它的格式：outer.inner(两者均为对象)
内部类为什么能直接访问外部类成员?
:是因为内部类持有外部类的一个引用，格式：Outer.this.x

（2）内部类的设计

当事物中内部事物需要访问外部事物的成员时，建立内部类

匿名内部子类对象：是内部子类的简写格式
实质是一个对象，这个对象有点胖
前提：匿名内部子类对象必须继承父类或者实现接口
基本格式：

 void  function()
{
        new Object()
       {
                void  method(){
                    System.out.println(“……………….”);
               }
       }
}

（3）匿名内部类的局限性
            a.只能一次性调用；
            b.创建父类或者接口引用，也只能调用父类或接口中存在的方法。
    事实上，一般为了方便，也不会创建自己特有的方法。

（4）代码演示：

class Outer
{
	public  int age=10;
	//成员位置上的内部类

	public  class Inner
	{
		//public int age=20;

		public void function(){
			System.out.println("age="+age);

		}
	}

	public void function(){
		/*//局部内部类
		class C
		{
			void print(){
				System.out.print("我是局部内部类");
			}
		}
		new C().print();
		*/
		//匿名内部类
		
	}
}

class Test
{
	public static void main(String [] args)

	{
		Outer o=new Outer();
		Outer.Inner i=new Outer().new Inner();

		//System.out.println(o.age);
		//System.out.println(i.age);
		//i.function();
		o.function();
		System.out.println();

		new Object(){
			void function(){
			System.out.println("匿名内部类");
				
			
			}
		}.function();
	}	
}

2、异常

（1）简介
问题也是一种事物，java中的问题分error(不可治愈)和Exception（可治愈）两大类，把共性的部分不断地向上抽取，形成了一个体系，这个父类是Rhrowable。

（2）异常处理
a,throw抛出；
b,try…catch。

异常声明：经可能详细，可声明多个，用多个catch处理，之间若有继承关系，父类往后放。
一般不打印，用日志文件记录异常，便于开发人员排查问题。

（3）自定义异常
a.继承exception
b.抛异常+声明异常
c.处理异常
d.可以创建自己特有的函数

（4）throw与throws区别

throw:用在函数内，后面跟函数对象
throws:用在函数上，后面跟函数名

（5）RunTimeException
RunTimeException该类及其子类很特殊，在函数内抛异常不需声明，这是因为：jvm不希望操作这处理，而希望程序停掉，修正代码。

（6）代码演示：

/*
老师用电脑讲课

电脑出问题:
1.蓝屏了
2冒烟了

电脑问题引起老师的问题
*/
class Compt
{
	private int state=3;
	public void run() throws MaoYan,LanPin
	{
		if(state==1)
			System.out.println("电脑运行");
		if(state==2)
			throw new LanPin();
		if(state==3)
			throw new MaoYan();
	}

	public void reset(){
		state=1;
		System.out.println("电脑重启");
	
	}	
}

class Teacher
{
	private String name;
 	private Compt compt;

	public Teacher(String name){
		
		this.name=name;
		compt=new Compt();
	}

	public void jiangKe() throws Jihua
	{
		try{
			compt.run();

		}catch(LanPin  e){
			compt.reset();
		}catch(MaoYan  e){
			throw new Jihua("冒烟了");
		}
		  System.out.println("老师讲课");
	}
}


class MaoYan extends Exception
{
	public MaoYan(){
		super();
	}

}

class LanPin extends Exception
{
	
	public LanPin(){
		super();
	}
}

class Jihua extends Exception
{
	
	public Jihua(String message){
		super(message);
	}
}


class Test
{
	public static void main(String [] args){
		try
		{
			Teacher t=new Teacher("zhuyutao");
			t.jiangKe();
		}
		catch(Jihua e)
		{
			System.out.println("换老师或放假"+e);
		
		}
		
	}
}

3、异常报告不准确的问题

a,异常又分为编译异常和运行异常
编译以异常：需要声明
运行异常：不需要声明

b,在日常中发现：
异常是层层抛出的，在功能函数上声明，在功能函数内部抛出，在调用时处理，处理分两种情况：能处理则处理、不能处理则转换抛出。

转化抛出，提供了解决之策，但也隐瞒了真实错误。（了解这一点，十分有利于排除异常）

练习题：

需求：获取一段程序运行的时间。

原理：获取程序开始和结束的时间并相减即可。

获取时间,System.currentTimeMillis();

当代码完成优化后，就可以解决这类问题。

这种方式，模版方法设计模式。

4，模版设计

在定义功能时，功能的一部分是确定的，但是有一部分是不确定，而确定的部分在使用不确定的部分。那么这时就将不确定的部分暴露出去。由该类的子类去完成。

第三章

1、分层思想
实质是数据封装，对象封装
如：异常的层层外抛，如果一个问题决解不了，先封装再抛出

小知识点：
Finally，肯定会执行的代码块（exit除外）。通常用来关闭资源。

Return 后面不能有语句。

throw封装在函数中时后面可以有语句，不在函数中时后面不能有语句。

2、异常补充

Try{

throw new xxException ("打印信息");

}catch(xxException e){

}
上述，写法是可以的，只要问题解决了，不用声明
Try{

throw new xxException();

}catch(xxException e){
throw e;

}
这种情况，编译不能通过，问题抛出没有解决，就得声明。

3、子父类异常

子父类异常：
子类只能抛继承的异常或者继承异常的子类；
子类特有的异常，必须处理。

异常分为：
编译时异常和运行时异常。
代码演示：

package pack;
/*
求图形的面积

过程中发生的问题，分装成异常对象

正常流程代码  应该和异常代码分开，提高阅读性

体系内基本功能用calss
体系外功能扩展用interface
以下，我们用接口

*/

interface Areaa
{
	 void getArea();
} 

class Rec implements Areaa
{	
	private int width;
	private int height;

	Rec(int width,int height){

		if(width<=0 || height<=0)
			throw new NoException("出错了");

		this.width=width;
		this.height=height;
	}

	public void getArea()
	{
		System.out.println(width*height);
	}

}

class Circle implements Areaa
{	
	private int radius;
	public static final double PI=3.14;

	Circle(int radius){

		if(radius<=0 )
			throw new NoException("出错了");

		this.radius=radius;

	}

	public void getArea()
	{
		System.out.println(radius*radius*PI);
	}

}

class NoException extends RuntimeException
{
	NoException(String msg){
		super(msg);
	}
}

class Test
{
	public static void main(String[] args)
	{
		try{
			new Rec(3,4).getArea();
			new Circle(-3).getArea();
		}catch(NoException e){
			System.out.println(e);
		}
	}
}

有错漏之处，欢迎指正！

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------