MyException - 我的异常网
当前位置:我的异常网» 编程 » JAVA-day08 午后-总结、测试

JAVA-day08 午后-总结、测试

www.MyException.Cn  网友分享于:2014-12-19  浏览:0次
JAVA-day08 下午-总结、测试
继承总结:

class  
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}
class Fu
{
	private int num = 9;
	public void show1(){}
	public void setNum(int num)
	{
		this.num  = num;
	}
	Fu(){}
}

class Zi extends Fu
{
	//int num = 4;

	void show()
	{
		int num = 7;
		System.out.println(super.num);
	}
}

Zi z = new zi();
z.setNum(4);
继承:
	特点:
		1,提高了代码的复用性。
		2,让类与类之间产生关系,是多态性的前提。

	Java中的继承。
		1,java只支持单继承,不支持多继承。为啥呢?答案:因为继承了多个父类如果有相同方法时,
												子类对象不确定运行哪一个。
		2,Java还支持多层继承。A-->B--->C  原来可以形成继承体系。
			想要使用体系功能,"查阅父类功能,建立子类对象调用功能。"
			注解:父类的由来其实是由事物中的共性内容不断向上抽取而来的。
				所以父类中定义的是该体系中的最基本,最共性功能。
	
	继承出现后,代码上也有一些特点:
	1,变量。
		当子父类中定义了相同的名称的成员变量,
		子类要使用父类中的同名变量时,需要使用关键字super来区分。
		一般不会出现这种情况,因为父类中有了,子类不需要定义。
		而且父类定义时,一般变量都私有化。

	2,函数。
		子类可以直接访问父类中非私有的成员函数。
		特殊情况:当子类中定义了与父类一模一样的方法时,会发生覆盖操作。大多指的是非静态方法。
				  最终会运行子类的方法,父类相当于被覆盖了。
				  函数的另一个特性:覆盖(重写,复写)。
				  什么时候用啊?
				  当父类的功能要被修改时,不建议修改源码。因为是灾难。
				  只要通过一个类继承原有类,定义一个新的升级后的功能即可。
				  但是功能是相同的,只是实现方法改变。这是子类可以沿袭父类中的功能定义,
				  并重写功能内容。这就是覆盖。

				  覆盖很爽,但是有注意事项:
				  1,子类覆盖父类时,必须权限要大于等于父类权限。
				  2,静态不能覆盖非静态。
			
	3,构造函数。
		构造函数可以本类进行对象初始化,也可以给子类对象进行初始化。
		子类对象初始化过程:
		子类中的所有构造方法都会访问父类中空参数的构造函数,
		因为每一个构造函数的第一行,都有一句隐式的super语句。
		为什么要有这条语句?
		因为子类会获取到父类中的数据,必须要先明确父类对数据的初始化过程。

		当父类中没有空参数构造函数时,子类构造函数必须通过super句来明确要访问的父类中指定的构造函数。

		当时子类构造函数也可以通过this语句访问本类中的构造函数。
		但是子类中肯定,至少有一个构造函数会访问父类。

	
抽象类:其实就是在分析事物时,事物中的功能有些是不明确的内容的。这些不明确内容就是抽象的。
		可以通过抽象函数来描述。

		抽象函数一定要定义在抽象类中,因为,抽象函数所在类,也必须被抽象标识。

		写法特点:
		1,抽象函数只对函数进行声明,没有函数主体。
		2,抽象类和抽象函数都需要用abstract修饰。
		3,抽象类不可以进行实例化。
		4,想要使用抽象功能,必须通过子类覆盖了父类中所有的抽象方法后,才可以对子类实例化。
			如果只覆盖了部分抽象方法,那么子类还是一个抽象类。

		也可以理解为:抽象类是一个父类,是不断向上抽取而来的,
		在抽取过程中,只抽取了方法声明,但没有抽取方法实现。

		抽象类和一半类差不多。
		区别:
		抽象类可以定义抽象方法。
		抽象类不可以建立对象。

		其实抽象类一样用于描述事物,既可以定义抽象方法,也可以定义非抽象方法。


	

接口
	 初期理解:接口看上去是一个特殊的抽象类。里面存的都是抽象方法。

	 特点:
	 格式:
		1,通过interface来定义。
		2,接口中常见成员:常量,抽象方法。
			而且这些成员都有固定的修饰符。
			常量:public static final
			方法:public abstract 
		3,接口中的成员都是共有的。
		4,一个类可以对接口进行多实现,也弥补了多继承带来的安全隐患,所以java对多继承进行了改良。
			用多实现方法来体现多继承的特性。
		5,一个类可以继承一个类的同时,实现多个接口。
		6,接口与接口之间是继承关系,而且可以多继承。


	应用特点:
		1,接口是对外暴露的规则。
		2,接口是功能的扩展。
		3,接口的出现降低了耦合性。
		别忘了说的时候,需要举例。如usb。pci,主板。插座。


抽象类和接口异同:
相同:
1,都可以在内部定义抽象方法。
2,通常都在顶层。
3,都不可以实例化,都需要子类来实现。

不同点:
1,抽象类中可以定义抽象方法和非抽象方法,
	而接口中只能定义抽象方法。
2,接口的出现可以多实现。
	抽象类只能单继承。
	也就是说:接口的出现避免了单继承的局限性。
3,继承和实现的关系不一致。继承:is a,实现:like a 





/*		

abstract class Fu
{
	abstract int show();
}

class Zi extends Fu
{
	int show1()
	{
		return 3;
	}
}

class  Fu
{
	void method()
	{
		System.out.println("method run");
	}
}

class Zi extends Fu
{
	void method()
	{
		System.out.println("method zi run");
	}
}




class ArrayTool
{
	public int getMax(int[] arr)
	{}
priavte int age;
	public void setAge()
}

运动员
	|--篮球运动员:
	|--足球运动员:
*/




多态总结:

abstract class 动物
{
	abstract void eat();
}

class Dog extends 动物
{
	public void eat()
	{
		//骨头;
	}
}

class 猫 extends 动物
{
	public void eat()
	{
		//吃鱼;
	}
}

class 猪 extends 动物
{
	public void eat()
	{
		//饲料;
	}
}

class Demo
{
	public void method(动物 x)//new Dog(); new 猫();
	{
		x.eat();
	}
	/*
	public void  method(猫 x)
	{
		x.eat();
	}
	public void  method(Dog x)
	{
		x.eat();
	}
	public void  method(猪 x)
	{
		x.eat();
	}
	*/
}

class Main
{
	public static void main(String[] args)
	{
		Demo d = new Demo();
		d.method(new Dog());
		d.method(new 猫());
	}
}



动物 x = new 猫();
//猫 x = new 猫();

一。表现:
父类或者接口的引用指向了或者接收了自己的子类对象。

二。前提:
1,类与类之间要有关系。继承,实现。
2,通常都会有覆盖。

三。好处:
预先定义的程序可以运行后期程序的内容。
增强了程序的扩展性。

四。弊端:
虽然可以预先使用,但是只能访问父类中已有的功能,运行的是后期子类的功能内容。
不能预先使用子类中定义的特有功能。

五。多态的注意事项:
在代码中。
对于成员函数:Fu f = new Zi(); f.method();
编译时期:看左边。
运行时期:看右边。
因为成员函数有一个覆盖操作。
	

	
对于非私有的实例变量,
静态变量,静态方法。

编译和运行都看左边。

老师要求记住结论。有空闲时间,就想想为什么?

六。转型。
子类对象被父类引用:子类对象在向上转型。
将指向子类对象的父类应用转换成子类类型引用:向下转型。





七。应用
电脑使用。主板运行。

class MainBoard
{
	public void run()
	{
		//主板运行;
	}
	public void usePCI(PCI p)//PCI p = new NetCard();
	{
		if(p!=null)
		{
			p.open();
			p.close();
		}
	}
}


//为了提高主板功能的扩展性。
//定义了规则。让后期的出现的功能板块,只要覆盖该规则,就可以被这个主板使用。
interface PCI
{
	void open();
	void close();
}




class MainDemo
{
	public static void main(String[] args)
	{
		MainBoard mb = new MainBoard();
		mb.run();
		mb.usePCI(null);
		mb.usePCI(new NetCard());



	}
}


class NetCard implements PCI
{
	public void open(){}
	public void close(){}
}


Object:是java中所有对象的直接或者间接的父类。
	它里面的方法都所有对象都具备的。
	常见方法:
	boolean equals(Object obj):用于比较两个对象是否相同。
	String toString(): 获取对象的字符串表现形式 类名@哈希值  
		getClass().getName()+"@"+Integer.toHexString(hashCode());
	Class getClass():获取正在运行的对象所属的字节码文件的对象。也就是说如果Demo d = new Demo();
				d.getClass():获取的就是d执行的对象所属的字节码文件Demo.class对象。
	
	通常在自定义对象时,因为对象中都有自己特有的描述,
	所以都会建立对象自身的特有比较方法,或者字符串表现形式。
	也就是说,会覆盖Object中的方法。


/*
Demo d1 = new Demo();
Demo d2 = new Demo();
d1.getClass() ==  d2.getClass();
*/


class Demo //extends Object
{
	public String toString()
	{
		this.getClass().getName()+"#"+Integer.toHexString(this.hashCode());
	}
}
	

class Fu
{
	void show(){System.out.println("fu show");}
}
class Zi extends Fu
{
	void function()
	{
		super.show();
		//this.show();
	}
	void show(){System.out.println("zi show");}
}




















/*

class Computer
{
	private MainBoard mb;

	Computer()
	{
		mb = new MainBoard();
	}
	public void play()
	{
		mb.run();
	}
}
*/








异常总结

异常:
是什么?是对问题的描述。将问题进行对象的封装。
------------
异常体系:
	Throwable
		|--Error
		|--Exception
			|--RuntimeException

异常体系的特点:异常体系中的所有类以及建立的对象都具备可抛性。
				也就是说可以被throw和throws关键字所操作。
				只有异常体系具备这个特点。


--------------
throw和throws的用法:

throw定义在函数内,用于抛出异常对象。
throws定义在函数上,用于抛出异常类,可以抛出多个用逗号隔开。


当函数内容有throw抛出异常对象,并未进行try处理。必须要在函数上声明,否则编译失败。
注意,RuntimeException除外。也就说,函数内如果抛出的RuntimeExcpetion异常,函数上可以不用声明。
--------------


如果函数声明了异常,调用者需要进行处理。处理方法可以throws可以try。

异常有两种:
	编译时被检测异常
		该异常在编译时,如果没有处理(没有抛也没有try),编译失败。
		该异常被标识,代表这可以被处理。
	运行时异常(编译时不检测)
		在编译时,不需要处理,编译器不检查。
		该异常的发生,建议不处理,让程序停止。需要对代码进行修正。



--------------
异常处理语句:
try
{
	需要被检测的代码;
}
catch ()
{
	处理异常的代码;
}
finally
{
	一定会执行的代码;
}

有三个结合格式:
1.	try
	{
		
	}
	catch ()
	{
	}

2.	try
	{
		
	}
	finally
	{
	
	}


3.	try
	{
		
	}
	catch ()
	{
	}
	finally
	{
	
	}



注意:
1,finally中定义的通常是 关闭资源代码。因为资源必须释放。
2,finally只有一种情况不会执行。当执行到System.exit(0);fianlly不会执行。

--------------

自定义异常:
	定义类继承Exception或者RuntimeException
	1,为了让该自定义类具备可抛性。
	2,让该类具备操作异常的共性方法。

	当要定义自定义异常的信息时,可以使用父类已经定义好的功能。
	异常异常信息传递给父类的构造函数。
	class MyException extends Exception
	{
		MyException(String message)
		{
			super(message);
		}
	}

自定义异常:按照java的面向对象思想,将程序中出现的特有问题进行封装。
--------------


异常的好处:
	1,将问题进行封装。
	2,将正常流程代码和问题处理代码相分离,方便于阅读。


异常的处理原则:
	1,处理方式有两种:try 或者 throws。
	2,调用到抛出异常的功能时,抛出几个,就处理几个。
		一个try对应多个catch。
	3,多个catch,父类的catch放到最下面。
	4,catch内,需要定义针对性的处理方式。不要简单的定义printStackTrace,输出语句。
		也不要不写。
		当捕获到的异常,本功能处理不了时,可以继续在catch中抛出。
		try
		{
			throw new AException();
		}
		catch (AException e)
		{
			throw e;
		}

		如果该异常处理不了,但并不属于该功能出现的异常。
		可以将异常转换后,在抛出和该功能相关的异常。

		或者异常可以处理,当需要将异常产生的和本功能相关的问题提供出去,
		当调用者知道。并处理。也可以将捕获异常处理后,转换新的异常。
		try
		{
			throw new AException();
		}
		catch (AException e)
		{
			// 对AException处理。
			throw new BException();
		}

		比如,汇款的例子。

	
异常的注意事项:
	在子父类覆盖时:
	1,子类抛出的异常必须是父类的异常的子类或者子集。
	2,如果父类或者接口没有异常抛出时,子类覆盖出现异常,只能try不能抛。








		














集合总结:

集合:可以存储不同类型的多个对象,随着存储对象的个数的增加而自动扩大容量

体系结构:
Collection<E>
  |----List:存入的对象是有序的,且可以重复
           ArrayList:底层使用的数据结构是数组,线程不安全的,查找速度快,增删速度慢
           Vector:底层使用的数据结构是数组,线程安全的,查找速度快,增删速度慢
           LinkedList:底层使用的数据结构是链表,线程不安全的,查找速度慢,增删速度快

  |----Set:存入的对象是无序的,且不可以重复
           HashSet:底层使用的数据结构是哈希表,线程不安全的
                   保证对象唯一的原理:
                   先判断hashCode()值,如果都不同就直接加入集合,如果哈希值相同了
                   在调用equals()方法,如果equals()方法返回值为true,则认为集合中存在
                   该对象,不加入集合

           TreeSet:底层使用的数据结构是二叉树,线程不安全的
                   会对存入集合的对象进行排序
                   保证集合中对象唯一的方式:依据compareTo()或compare()的返回值是否为0
                    排序方式一:让存入集合中的对象具备可比较性
                                让存入集合中的对象所属的类实现Comparable<T>接口中的
                                int compareTo(T t) 方法
                    排序方式二:让集合具备排序功能
                                定义一个比较器,实现Comparator<T>接口中的 int compare(T t1,T t2)方法
                                把比较器对象作为参数传递给TreeSet<E>集合的构造方法

                    当集合中的对象具备可比较性,且存在比较器时,比较器优先被使用

泛型:<引用数据类型>
       把运行时期的问题转移到了编译时期
       不用再强制类型转换
 
     class Demo<T>
     {
          public void show(T t)
          { }

          //自己使用泛型的方法
          public <E> void fun(E e)
          {
          }

          //静态方法只能自己使用泛型
          public static <W> void func(W w)
          {}
      }

    //泛型定义在接口上
    interface inter<T>
    { }

    通配符:?
    泛型限定:? extends E  和 ? super E


Map<K,V>:一个单独的接口,存储的是键值对,键不可以重复,无序的

         HashMap:保证键唯一的原理和HashSet一样,hashCode(),equals()

         TreeMap:TreeMap是根据键来排序的,保证键唯一的原理和TreeSet相同,依据
		 compareTo()或compare()的返回值是否为0,为0就认为是重复键

         Map的迭代方式有两种:
         第一种:
                 Set<K> keys  =map.keySet();
                 Iterator<K> ite = keys.iterator();
                 while(ite.hasNext())
                 {
                    K key = ite.next();
                    V value = map.get(key);
                    System.out.println(key+","+value);
                 }
         第二种:
                Set<Map.Entry<K,V>> entry = map.entrySet();
                Iterator<Map.Entry<K,V>> ite = entry.iterator();
                while(ite.hasNext())
                {
                   Map.Entry<K,V> en = ite.next();
                   K key = en.getKey();
                   V value = en.getValue();
                   System.out.println(key+","+value);
                }


工具类:Arrays
        Collections

增强的for循环
可变参数
静态导入










测试题目:

一:简答题

1. 两个对象值相同(x.equals(y) == true),但却可有不同的哈希值,这句话对不对(5)
  对

2.接口是否可以继承接口? 抽象类是否可以实现(implements)接口? 抽象类是否可以继承实体类? (5)

 可以,可以,可以

3. try {}里有一个return语句,那么紧跟在这个try后的finally {}里的代码会不会被执行,什么时候被执行,在return前还是后? (5)
       会,return

4. StringStringBuffer的区别(5)
     StringBuffer 添加串是属于一个对象。 字符串相加会产生新的常量

二:编程题

1:计算付款金额一杯5每两杯的第二杯半价(杯数由用户从键盘录入 )  : 5杯 = (5+2.5)*2 + 5 = 20   (10)

 

2:分别统计字符串"123456789012"奇数位及偶数位上的数字的和(10

     将字符串的奇数位数字相加求和 c1 = 1 + 3 + 5 + 7 + 9 + 1

     将字符串的偶数位数字相加求和 c2 = 2 + 4 + 6 + 8 + 0 + 2

 

3String[] cards = {"3","4","8","A","K","Q"}数组中存储了6张牌,设计一个算法把牌打乱,也就是实现洗牌功能(10)

 

4一个5位的整数,判断它是不是回文数,例如12321是回文数(10分)

 

5:向一个有序的整型数组中插入一个数,插入后该数组还是有序的

(使用二分法)(15)

 

6:实现随机生成双色球号码:   例如: [02 22 13 16 18 12] [12](25)

  红球 33 个球 (01~33) 取 六

  蓝球 16 个球 (01~16) 取 一 

  提示:  

  蓝球池  {"01", "02", "03", "04", ... "16"} 

  红球池  {"01", "02", "03", "04", ... "33"} 

  使用标记{   f,    f,    f,    f, ...    f}

  

  结果采用一个数组存储数组可以利用数组扩容追加新的"球号"

  处理逻辑参考如下过程: 

  1 随机生成红球序号

  2 检查"红球序号"是否使用过(取出过

    如果使用过 返回 1

  3 取出一个红球设置使用标记为true

  4 是否取出了6个红球

    如果没有到6返回 1

  5 对红球结果排序

  6 取出一个篮球到结果中


文章评论

初级 vs 高级开发者 哪个性价比更高?
初级 vs 高级开发者 哪个性价比更高?
做程序猿的老婆应该注意的一些事情
做程序猿的老婆应该注意的一些事情
什么才是优秀的用户界面设计
什么才是优秀的用户界面设计
Java 与 .NET 的平台发展之争
Java 与 .NET 的平台发展之争
程序猿的崛起——Growth Hacker
程序猿的崛起——Growth Hacker
写给自己也写给你 自己到底该何去何从
写给自己也写给你 自己到底该何去何从
程序员周末都喜欢做什么?
程序员周末都喜欢做什么?
“懒”出效率是程序员的美德
“懒”出效率是程序员的美德
60个开发者不容错过的免费资源库
60个开发者不容错过的免费资源库
每天工作4小时的程序员
每天工作4小时的程序员
程序员最害怕的5件事 你中招了吗?
程序员最害怕的5件事 你中招了吗?
那些性感的让人尖叫的程序员
那些性感的让人尖叫的程序员
Web开发者需具备的8个好习惯
Web开发者需具备的8个好习惯
中美印日四国程序员比较
中美印日四国程序员比较
2013年中国软件开发者薪资调查报告
2013年中国软件开发者薪资调查报告
要嫁就嫁程序猿—钱多话少死的早
要嫁就嫁程序猿—钱多话少死的早
我的丈夫是个程序员
我的丈夫是个程序员
看13位CEO、创始人和高管如何提高工作效率
看13位CEO、创始人和高管如何提高工作效率
2013年美国开发者薪资调查报告
2013年美国开发者薪资调查报告
老美怎么看待阿里赴美上市
老美怎么看待阿里赴美上市
科技史上最臭名昭著的13大罪犯
科技史上最臭名昭著的13大罪犯
程序员和编码员之间的区别
程序员和编码员之间的区别
不懂技术不要对懂技术的人说这很容易实现
不懂技术不要对懂技术的人说这很容易实现
十大编程算法助程序员走上高手之路
十大编程算法助程序员走上高手之路
如何成为一名黑客
如何成为一名黑客
那些争议最大的编程观点
那些争议最大的编程观点
总结2014中国互联网十大段子
总结2014中国互联网十大段子
编程语言是女人
编程语言是女人
当下全球最炙手可热的八位少年创业者
当下全球最炙手可热的八位少年创业者
鲜为人知的编程真相
鲜为人知的编程真相
团队中“技术大拿”并非越多越好
团队中“技术大拿”并非越多越好
“肮脏的”IT工作排行榜
“肮脏的”IT工作排行榜
程序员眼里IE浏览器是什么样的
程序员眼里IE浏览器是什么样的
程序员的鄙视链
程序员的鄙视链
10个帮程序员减压放松的网站
10个帮程序员减压放松的网站
代码女神横空出世
代码女神横空出世
程序员都该阅读的书
程序员都该阅读的书
如何区分一个程序员是“老手“还是“新手“?
如何区分一个程序员是“老手“还是“新手“?
10个调试和排错的小建议
10个调试和排错的小建议
程序员应该关注的一些事儿
程序员应该关注的一些事儿
一个程序员的时间管理
一个程序员的时间管理
亲爱的项目经理,我恨你
亲爱的项目经理,我恨你
旅行,写作,编程
旅行,写作,编程
5款最佳正则表达式编辑调试器
5款最佳正则表达式编辑调试器
Java程序员必看电影
Java程序员必看电影
程序员必看的十大电影
程序员必看的十大电影
我是如何打败拖延症的
我是如何打败拖延症的
我跳槽是因为他们的显示器更大
我跳槽是因为他们的显示器更大
为啥Android手机总会越用越慢?
为啥Android手机总会越用越慢?
软件开发程序错误异常ExceptionCopyright © 2009-2015 MyException 版权所有