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或者RuntimeException1,为了让该自定义类具备可抛性。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 EMap<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. String与StringBuffer的区别(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

 

3：String[] 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 取出一个篮球到结果中