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 取出一个篮球到结果中


郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。