继承总结:

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,变量。
当子父类中定义了同样的名称的成员变量。
子类要使用父类中的同名变量时,须要使用keywordsuper来区分。
一般不会出现这样的情况。由于父类中有了,子类不须要定义。 并且父类定义时。一般变量都私有化。 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和throwskeyword所操作。
仅仅有异常体系具备这个特点。 --------------
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. 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 取出一个篮球到结果中

JAVA-day08 下午-总结、測试的更多相关文章

  1. 【JUnit4.10源码分析】3.4 Description与測试树

    Description使用组合模式描写叙述一个測试树.组合模式中全部元素都是Composite对象. Description有成员变量private final ArrayList<Descri ...

  2. 使用maven运行单元測试总结

    maven本身没有单元測试框架,可是maven的default生命周期的test阶段绑定了maven-surefire-plugin插件,该插件能够调用Junit3.Junit4.TestNG等Jav ...

  3. JNI/NDK开发指南(九)——JNI调用性能測试及优化

    转载请注明出处:http://blog.csdn.net/xyang81/article/details/44279725 在前面几章我们学习到了.在Java中声明一个native方法,然后生成本地接 ...

  4. Android网络传输中必用的两个加密算法:MD5 和 RSA (附java完毕測试代码)

    MD5和RSA是网络传输中最经常使用的两个算法,了解这两个算法原理后就能大致知道加密是怎么一回事了.但这两种算法使用环境有差异,刚好互补. 一.MD5算法 首先MD5是不可逆的,仅仅能加密而不能解密. ...

  5. java的junit測试

    在实际的开发中不仅须要断点调试.语句输出的方法进行程序的调试,也须要单元測试. 在java中的junit的測试方法通常是在要測试的方法上面加入@Test.@ Before.@After,@Before ...

  6. java 搭建webservice服务+testclient測试

    整理别人的日志: 一.什么是webservice 一种构建应用程序的普遍模型,能够在不论什么支持网络通信的操作系统中执行.一种新的web应用程序分支,能够公布.定位通过web调用.它是一个应用组件,为 ...

  7. 菜鸟学Java(二十一)——怎样更好的进行单元測试——JUnit

    測试在软件生命周期中的重要性,不用我多说想必大家也都很清楚.软件測试有许多分类,从測试的方法上可分为:黑盒測试.白盒測试.静态測试.动态測试等:从软件开发的过程分为:单元測试.集成測试.确认測试.验收 ...

  8. 用java打暴雪星际争霸(2)——执行測试机器人

    原创内容.转载请注明. 在上一节安装完成后.或者您直接打开我分享的虚拟机后,我如今将解说怎样启动測试机器人. 第一步,打开Eclipse,导入机器人演示样例项目,如图所看到的. 第二步,我们能够看到就 ...

  9. #測试相关#Getting “junit.framework.AssertionFailedError: Forked Java VM exited abnormally” Exception

    编写Ant脚本进行持续測试的时候.出现了junit.framework.AssertionFailedError: Forked Java VM exited abnormally的报错,以此为key ...

随机推荐

  1. GoLang中如何使用多参数属性传参

    我们常常因为传入的参数不确定而头疼不已,golang 为我们提供了接入多值参数用于解决这个问题.但是一般我们直接写已知代码即所有的值都知道一个一个塞进去就好了,但是绝大部分我们是得到用户的大量输入想通 ...

  2. MongoDB学习笔记(三)--权限 && 导出导入备份恢复 && fsync和锁

    权限                                                                                             绑定内网I ...

  3. Linq-分页查询

    var list = from s in db.t_address select s; & userid != null) { list = list.Where(v => v.user ...

  4. 如何快速去掉.svn文件夹?

    我们在工程的协作开发过程中,常用的是 svn , 有时我们需要一个干净的 网站版本,没有 .svn 这些文件夹记录的版本传到服务器上使用,自己一个个去文件删除的话也太累了,这时我们就用到以下功能,用c ...

  5. PHP高级教程-包含

    PHP 包含文件 PHP include 和 require 语句 在 PHP 中,您可以在服务器执行 PHP 文件之前在该文件中插入一个文件的内容. include 和 require 语句用于在执 ...

  6. PHP中静态方法(static)与非静态方法的使用及区别

    今天再次学习这个内容,总是糊里糊涂的,想弄明白!!! static关键字用来修饰属性.方法,称这些属性.方法为静态属性.静态方法.static关键字声明一个属性或方法是和类相关的,而不是和类的某个特定 ...

  7. Spring Web MVC 原理学习(下)

             接着上一篇博客,这一篇.我们依据一个简单的demo,来对SpringMVC的原理再次学习:   一.配置web.xml                   我们新建一个web项目.在 ...

  8. spring task:annotation-driven 定时任务

    1.配置文件加上<task:annotation-driven/> 2.要运行的方法前加上 @Scheduled(cron="0 00 12 1 * ?")  //每月 ...

  9. Lua 字符串库函数总结

    字符串库 注:字符串在Lua中是不可变的.不论什么的string操作都不会去改变原有的字符串.都是返回新的字符串 一.一般函数 1. 求长度 s = "Hello LUA "; p ...

  10. 在交叉编译中使用最新版的SS

    因为旧版本的ss-local总是出现 shake hands failed 错误, 打算用最新的版本试试, 所以尝试在编译中使用最新版的shadowsocks. 项目地址 Shadowsocks-li ...