标签：可靠性 重复 外部程序 常用 工程 ati 字段 .com cep
|
Public class ConstructorMethod { String name; Int age;// 成员变量 Public ConstructorMethod(String name, int age) { //有参构造方法,构造方法无返回类型 this.name = name; this.age = age;//实例的属性 = 实参; } Publicstaticint Case1() {//成员方法 System.out.println("我是Case1调用"); return0; } } |
举例：center.name = "北京中心"; //给name属性赋值
举例：center.showCenter(); //调用showCenter()方法
举例：School center = new School();
基本数据类型为初始化为0，布尔类型为false，引用类型为null。
|
publicclassTest { publicstaticvoidmain(String[] args) { Catcat = null; //局部变量需要初始化或传实参 Petpet = newCat(); cat = (Cat)cat; } }
classPet { }
classCatextendsPet { } |
一般格式：访问修复符 返回值类型 方法名(参数列表）{方法体};
类的访问权限有Public和Default两种，类中成员的访问权限有下列四种：
补充：继承权限测试.Package 。
继承权限测试(类之间) & 访问权限测试(属性和方法)测试结果：
u 类的访问修饰符只有public和默认两种。
u 类中成员 public(公共修饰符) --> protected(子类) --> default(包)--> private(私有)
u 局部变量作用域确定，故没有访问修饰符，访问修饰符仅针对成员变量和方法。
u 子类对父类的访问，直接调用属性或方法(其实隐含this.调用)。
u 非继承关系或父类对子类的访问的访问方式，需用对象或类名访问。
u 访问权限是基于继承决定的，继承权限也是一种访问权限。
u 继承则属性和方法归父类和子类共有,但除私有成员不可以访问。
u 子类可以选择重写父类的属性和方法的访问修饰符，权限不能小于父类
方法重载，就是在同一个类里中可以创建多个方法，方法名要一样，参数列表不同，和访问修饰符 、返回值无关。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法，是一个类中多态性的一种表现。
方法重写，在子类和父类之间对，父类的函数进行重新定义。子类名称和参数别表与父类相同，方法体重写。
所谓构造方法，就是构造对象的方法，通过new + 构造方法， 这样就创建了一个新的对象。
|
publicclassTest { privateStringname; publicTest(){ this.name = "小新"; } publicTest(Stringname) { System.out.println("我是" +this.name); } publicstaticvoidmain(String[] args) { Testtest = newTest("小强"); } }//运行结果：我是null（实参没有该成员变量赋值） |
|
publicclassTest { publicstaticvoidmain(String[] args) { for (inti = 0; i<args.length; i++) { System.out.println("args" + i + "=" + args[i]); } } } 输出结果： args0=args1 args1=args2 |
|
u intmonth = 4; u intday = input.nextInt(); 注：作为形参的变量的初始化便是传入实参。 |
待补充~
内部类将相关的类组织在一起，从而降低了命名空间的混乱。一个内部类可以定义在另一个类里，可以定义在函数里，甚至可以作为一个表达式的一部分。内部类可以直接访问外部类中的成员。而外部类想要访问内部类，必须要建立内部类的对象。
http://blog.sina.com.cn/s/blog_accab4a90101gzh2.html
匿名内部类也就是没有名字的内部类，正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口。
|
abstractclassPerson { publicabstractvoideat(); }
publicclassDemo { publicstaticvoidmain(String[] args) { Personp = newPerson() { publicvoideat() { System.out.println("eat something"); } }; p.eat(); } } |
一个类可以使用不包含在任何方法体中的静态代码块，当类被载入时，静态代码块被执行，且只被执行一次，静态块常用来执行类属性的初始化。
|
static { System.out.println ("Hello Everyone"); } |
方法里不可以定义static
待补充~
这个关键字是一个修饰符，可以修饰类，方法，变量。
|
publicclassTest { privateStringname;//将类的属性进行封装 publicStringgetName() {//并提供可带判断条件的访问方法 returnname; }
publicvoidsetName(Stringname) { this.name = name; } } |
将类的属性隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。
修改属性的可见性（设为private，防止错误的修改）à创建公有的getter/setter方法（用于属性的读写）à在getter/setter方法中加入属性控制语句（对属性值的合法性进行判断）。
|
classPerson { // 父类 privateStringname; publicstaticintage; publicstaticStringsex;
publicPerson() { // 会自动生成无参构造器 System.out.println("父类构造器"); }; // 但是考虑继承的可靠性，建议写上。
publicvoidsetName(Stringname) { this.name = name; }
publicStringgetName() { returnthis.name; } }
classStudentextendsPerson { // 子类 privateStringschool;
publicStudent() { // 子类student中构造 super(); //super只可在子类中使用 System.out.println("子类构造器"); } } publicclassTestExtendDemo {// 测试类 publicstaticvoidmain(String[] args) { Person.age = 18; Student.age = 19; // 继承父类的成员属性和方法可直接调用 Person.sex = "男"; // 静态变量或方法用类调用 System.out.println(Student.age+Person.sex); Scannerinput = newScanner(System.in); Studentsomeone = newStudent(); //创建子类对象的过程 someone.setName(input.next()); // 实例变量和方法用实例调用 System.out.println(someone.getName()); } } |
继承是面向对象最显著的一个特性。多个类中存在相同属性和方法时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和方法，只要继承那个类即可。继承是代码重用的一种方式。Java通过extends关键字来实现单继承。（Is a）
访问父类属性：super.name;
调用父类方法：super.print();
原因：子类的所有构造器中的第一行，其实都有一条隐身的语句super(), super()表示调用父类的无参构造器。子类继承父类中的属性，在new 子类的时候，相应的父类的属性也就拿到了，这就是子类的实例化过程。
然而父类有有参构造器，则无参构造器就不存在了，所以在子类中须在第一行显式调用super(参数)，或者在父类中添加一个无参构造器。之所以须在第一行调用，是因为父类的构造器调用以及初始化过程一定在子类的前面。
并且，父类也被new一个对象出来的说法是错误的，举例抽象类可以被继承的，但抽象类不能被实例化。
参考：Java中属性的隐藏与方法的覆盖的区别
参考：静态绑定与动态绑定
u 子类方法重写时方法名、参数、返回值、返回类型均须相同。访问权限不小于父类。
解析：确保子类可以重写父类。父类不能覆盖子类。
u 重写是父子类要么都静态，要么都不静态。
u 子类可以定义与父类同名的静态方法，以便在子类中隐藏父类的静态方法。
u 父类的私有方法不可访问，不能被子类重写。
|
abstractclassAnimal {// 因为本身实例化没有意义，所以一般申明为抽象类 Animal() { // 会自动生成无参构造器 }; // 但是考虑继承的可靠性，建议写上。
abstractvoideat();// 抽象方法 } classCatextendsAnimal { // 1、继承父类 publicvoideat() { // 2、子类方法的重写 System.out.println("吃鱼"); }
publicvoidcatchMouse() { //子类私有方法，只能用子类对象调用 System.out.println("抓老鼠"); } }
classDogextendsAnimal { // 1、继承父类 publicvoideat() { // 2、子类方法的重写 System.out.println("吃骨头"); }
publicvoidkanJia() { System.out.println("看家"); } }
classDuoTaiDemo { // 类名与源文件相同，否则无法运行 publicstaticvoidmain(String[] args) { function(newCat()); // new Cat() 表示构造一个猫的对象 function(newDog());
//Animal a;//对象可像变量一样声明和传递参数 //a= new Cat(); //父类为抽象类，不能实例化，但能创建引用 Animala=newCat(); // 向上转型 // 类似变量传参，new Cat()是参数 a.eat(); //3.父类对象引用指向子类对象 PS:须先满足前两个条件 }
publicstaticvoidfunction(Animala) {//对象可作变量传递参数 a.eat(); //3.父类对象引用指向子类对象 PS:须先满足前两个条件
if (ainstanceofCat) {// 用于判断对象是否为指定类的实例 Catc = (Cat) a; // 向下转型，由Animal(父)类转为Cat(子)类 c.catchMouse();// 向下转型，调用子类特有属性 } elseif (ainstanceofDog) { Dogc = (Dog) a; c.kanJia(); } } |
|
publicclassPolymorphism {// 多态传参 ,取例 Think in Java Void doStuff(Shapes) {// 形参 s.erase(); // ... s.draw(); }
Public static void main(String[] args) {
Circle c = new Circle();// Circle/Triangle/Line是Shape的子类 Triangle t = new Triangle(); Line l = new Line(); doStuff(c);// 实参 doStuff(t); doStuff(l); } } |
指允许不同类的对象对同一消息做出响应。即同一消息可以根据发送对象的不同而采用多种不同的行为方式。（发送消息就是方法调用），与方法不同的是对象的属性则不具有多态性。
动态绑定：是指在程序运行时判断所引用对象的实际类型，根据其实际的类型调用其相应的方法，是多态实现的具体形式。执行动态绑定的非静态方法
补充知识：静态绑定：又称为前期绑定在程序编译时进行了绑定，即在还没运行时，就已经加载到内存。执行静态绑定的有变量和静态方法
接口实现，继承父类进行方法重写，同一个类中进行方法重载。当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的该同名方法。
消除类型之间的耦合关系
u 成员变量：在多态中，子父类成员变量同名。
在编译时期：参考的是引用型变量所属的类中是否有调用的成员。（编译时不产生对象，只检查语法错误）
运行时期：也是参考引用型变量所属的类中是否有调用的成员。
简单一句话：无论编译和运行，成员变量参考的都是引用变量所属的类中的成员变量。再说的更容易记忆一些：成员变量à编译运行都看 = 左边。
u 静态函数
编译时期：参考的是引用型变量所属的类中是否有调用的成员。
运行时期：也是参考引用型变量所属的类中是否有调用的成员。
为什么是这样的呢？因为静态方法，其实不属于对象，而是所属于该方法所在的类。
调用静态的方法引用是哪个类的引用调用的就是哪个类中的静态方法。
简单说：静态函数à编译运行都看 = 左边。
u 成员函数
编译时期：参考引用型变量所属的类中是否有调用的方法。
运行事情：参考的是对象所属的类中是否有调用的方法。
为什么是这样的呢？因为在子父类中，对于一模一样的成员函数，有一个特性：覆盖。
简单一句：成员函数，编译看引用型变量所属的类，运行看对象所属的类。
更简单：成员函数à编译看 = 左边，运行看 = 右边。
|
publicabstractclassClassName { int name; abstractvoidfun(); } |
|
publicinterfaceInterfaceName { public abstractvoid cry(); } classClassNameimplementsInterface1,Interface2....{ } |
在软件工程中，接口泛指供别人调用的方法或者函数。从这里，我们可以体会到Java语言设计者的初衷，它是对行为的抽象。
接口是抽象方法的集合。如果一个类实现了某个接口，那么它就继承了这个接口的抽象方法。这就像契约模式，如果实现了这个接口，那么就必须确保使用这些方法。
接口主要用来描述类具有什么功能，自身不能做任何事情。具体实现交由实现接口的那个类来完成。
|
参数 |
抽象类 |
接口 |
|
默认的方法实现 |
它可以有默认的方法实现 |
所有的方法都是抽象的。不存在方法的实现 |
|
实现 |
子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现。 |
子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现 |
|
构造器 |
抽象类有构造器，用于子类初始化 |
接口不能有构造器 |
|
普通类 |
除了不能实例化抽象类之外，它和普通Java类没有任何区别 |
接口是完全不同的类型 |
|
访问修饰符 |
抽象方法可以有public、protected和default这些修饰符 |
接口方法默认修饰符是public。不可以使用其它修饰符。 |
|
main方法 |
抽象方法可以有main方法并且我们可以运行它 |
接口没有main方法，因此我们不能运行它。 |
|
多继承 |
抽象方法可以继承一个类和实现多个接口 |
接口只可以继承一个或多个其它接口 |
|
速度 |
它比接口速度要快 |
接口是稍微有点慢的，因为它需要时间去寻找在类中实现的方法。 |
|
添加新方法 |
如果你往抽象类中添加新的方法，你可以给它提供默认的实现。因此你不需要改变你现在的代码。 |
如果你往接口中添加方法，那么你必须改变实现该接口的类。 |
抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。举个简单的例子，飞机和鸟是不同类的事物，但是它们都有一个共性，就是都会飞。那么在设计的时候，可以将飞机设计为一个类Airplane，将鸟设计为一个类Bird，但是不能将 飞行 这个特性也设计为类，因此它只是一个行为特性，并不是对一类事物的抽象描述。此时可以将 飞行 设计为一个接口Fly，包含方法fly( )，然后Airplane和Bird分别根据自己的需要实现Fly这个接口。然后至于有不同种类的飞机，比如战斗机、民用飞机等直接继承Airplane即可，对于鸟也是类似的，不同种类的鸟直接继承Bird类即可。从这里可以看出，继承是一个 "是不是"的关系，而 接口 实现则是 "有没有"的关系。如果一个类继承了某个抽象类，则子类必定是抽象类的种类，而接口实现则是有没有、具备不具备的关系，比如鸟是否能飞（或者是否具备飞行这个特点），能飞行则可以实现这个接口，不能飞行就不实现这个接口。
设计层面不同，抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范，它是一种辐射式设计。什么是模板式设计？最简单例子，大家都用过ppt里面的模板，如果用模板A设计了ppt B和ppt C，ppt B和ppt C公共的部分就是模板A了，如果它们的公共部分需要改动，则只需要改动模板A就可以了，不需要重新对ppt B和ppt C进行改动。而辐射式设计，比如某个电梯都装了某种报警器，一旦要更新报警器，就必须全部更新。也就是说对于抽象类，如果需要添加新的方法，可以直接在抽象类中添加具体的实现，子类可以不进行变更；而对于接口则不行，如果接口进行了变更，则所有实现这个接口的类都必须进行相应的改动。
Java异常处理的目的是提高程序的健壮性。你可以在catch和finally代码块中给程序一个修正机会，使得程序不因不可控制的异常而影响程序的流程。同时，通过获取Java异常信息，也为程序的开发维护提供了方便。
RuntimeException类及其子类都被称为运行时异常，这种异常的特点是Java编译器不去检查它，也就是说，当程序中可能出现这类异常时，即使没有用try...catch语句捕获它，也没有用throws字句声明抛出它，还是会编译通过。
除了RuntimeException类及其子类外，其他的Exception类及其子类都属于受检查异常，这种异常的特点是要么用try...catch捕获处理，要么用throws语句声明抛出，否则编译不会通过。
运行时异常表示无法让程序恢复运行的异常，导致这种异常的原因通常是由于执行了错误的操作。
受检查异常表示程序可以处理的异常。受检查异常表示程序可以处理的异常。如果抛出异常的方法本身不处理或者不能处理它，那么方法的调用者就必须去处理该异常，否则调用会出错，连编译也无法通过。
当然，这两种异常都是可以通过程序来捕获并处理的，比如除数为零的运行时异常。
异常处理机制为：抛出异常，捕捉异常。
|
import java.util.InputMismatchException; import java.util.Scanner;
publicclassTryCatch { publicstaticvoidmain(String[] args) { Scannerinput = newScanner(System.in);
try {// 可能会发生异常的程序代码 System.out.print("请输入一个数字:"); inta = input.nextInt(); } catch (InputMismatchExceptione) {// 捕捉异常 System.err.println("数据类型不符!"); e.printStackTrace(); System.err.println(e.getMessage()); // return; 若捕捉到异常会先执行finally, 再return。 } catch (Exceptione) {// catch 先写子类，再写父类 System.out.println("再捕捉一次!"); System.exit(1); } finally {// 除非执行System.exit(1)，否则都会执行 System.out.println("finally 被执行!"); // 应用举例：确保关闭数据库，关闭流 }
System.out.println("我还是被执行了!"); // 如果提前return，则不执行了 } } |
|
publicclassThrows {
publicstaticvoidmain(String[] args) throws Exception{ System.out.println(10 / 0); thrownewException("抛出异常"); //System.out.println("throw后面的代码不再执行"); } } |
数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
算术条件异常。譬如：整数除零等。
空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等
找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。
待补充~
如果出现异常的线程为主线程，则整个程序运行终止；如果非主线程，则终止该线程，其他线程继续运行。
如果父类或者接口中的方法没有抛出过异常，那么子类是不可以抛出异常的，如果子类的覆盖的方法中出现了异常，只能try不能throws。
如果这个异常子类无法处理，已经影响了子类方法的具体运算，这时可以在子类方法中，通过throw抛出RuntimeException异常或者其子类，这样，子类的方法上是不需要throws声明的。
越早处理异常消耗的资源和时间越小，产生影响的范围也越小。
标签：可靠性 重复 外部程序 常用 工程 ati 字段 .com cep
原文地址：http://www.cnblogs.com/bugdeaitaigaoshang/p/6881791.html
