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

------ 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培训、期待与您交流！ -------

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

继续阅读

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method

JSONObject包导入异常 java.lang.NoClassDefFoundErrorweb项目的导入包的问题