JAVA基础笔记(二)

17．方法覆盖

   父子类之间满足一下条件可以override：

   （1） 方法名、方法签名一致；

   （2） 子类修饰符的限定范围不能小于父类的修饰符

   （3） 如果子类抛出的异常类型与父类抛出的异常类型有继承关系，那么子类异常类型不能是其父类异常类型的父类或更高，否则子类的Exception 会抢先throws，导致父类Exception失效。

 

18．Polymorphism运行机制：

在类编译阶段，编译器会检查类型是否匹配（检查声明类型、方法等）。在运行阶段，JVM会调用实例的对应方法，先检查父类方法，后检查子类方法。然后编译器会检查实例声明的类型。

 

19．什么是OOP？OOP相对于面向过程编程有哪些优点？

OOP，Object-Oriented Programming，面向对象编程不同于面向过程编程：

（1）OOP关注对象和角色，也就是事物的本质

     1）OOP把客观世界中的对象抽象成对应的类；

     2）通过类构造实例；

     3）通过依赖、继承、实现等形式建立对象间的通信关系

（2）OOP易于扩展，增加或改变业务的功能，无需大幅改动改变源代码

（3）OOP易于建模，OOP就是软件架构师在计算机高级语言中对客观世界的抽象和再现，人们可以很好地理解和建立起计算机中的抽象模型

面向过程编程：

关注的是事物的行为、实现步骤、实体的操作；

面向过程编程的代码是分散的，不具备良好的架构和设计理念；

应对变化的能力很差，往往牵一发而动全身。

例如在一个象棋游戏程序中，OOP关注棋盘、棋手和规则三个对象以及它们之间的关系，而不关心下棋的各种各样的步骤。

 

20．static成员常用来提前做全局的初始化工作。

21．super

   （1）调用父类的属性；

（2）调用父类的方法；

（3）子类与父类有同名的方法，子类可用super.methodname来区分是父类的方法；

 

22．怎样使用抽象类？

（1）尽可能把可以共用的方法和逻辑放到抽象类中；

（2）属性应尽可能放到子类中。

 

     Chapter 06

                               Advanced Language and Features

1.final

    final修饰的类不能被继承;

    final修饰的方法不能被override

    final修饰的变量是常量,常量不可修改,但有例外:

       实例常量:

       A.若定义时为赋值,则可以在构造器或者实例代码块中赋值

       B.构造器或者代码块赋值只能有一个

       静态常量:

            若定义时没有赋值,可在静态代码块中赋值

2.抽象类:

     定义:

         具有部分实现的类.

     格式:

       abstract class(){

       }

     使用:

         1.不能实例化

         2.可有零到多个抽象方法

         3.可有构造器

         4.具体类继承抽象类时,必须实现所有的抽象方法

         5.抽象类可以间接地被子类调用其构造器,并且在内存中分配空间,间接实例化

         6.抽象类可以有静态方法,可以返回其子类的实例

         7.抽象类可以被执行

     抽象类使用注意事项:

         1.把各个类中可以共用的方法和逻辑放到抽象的父类中,越多越好

         2.属性应该尽可能地放在子类中

     模板方法的使用:

         1.在抽象的父类中定义高层的业务逻辑final method( ){ };

         2.在抽象类父类中定义抽象的方法:abstract step1(); abstract step2();......

         3.子类实现相应的抽象方法

         4.调用者调用final方法

         5.抽象方法的扩展可以在final方法中加入前置或者后置方法(这些方法应该是实例方法,提供空的实现)

        

     为什么要使用抽象类?

     里氏代换:基类(父类)能够出现的地方,子类一定能够出现.

     大部分情况下,是从大多数对象中抽象出的属性和方法,是为了方便代码的复用.

     抽象类的存在,就是为了继承.

    

     怎样使用抽象类?

     A.在抽象类中共有的代码和逻辑,应该尽量地多.共用的业务逻辑(具体方法)应该;尽可能地放在抽象类中.

     B.属性尽可能放在具体类中.

3. interface（接口）

     一 什么是接口?

     (1) 接口应该是一个规范(宏观)

     (2) 接口是一种抽象类型:

            (1)属性是常量,一定要赋值

            (2)方法是抽象方法

            (3)没有构造器

            (4)接口支持casting

            (5)类中,接口中定义内部的接口

             A implements ID.IE:不必要实现ID中的方法

             A implements ID:不必要实现IE中的方法

             类中定义的接口,可以有修饰符

            (6)接口可以继承多个接口

            (7)实现接口的类必须要实现所有的方法,如果是抽象类可以选择实现部分的方法

            (8)如果又要继承类又要继承接口:

             A extends SuperA implements I1,I2

            

            

        接口没有任何实现,但有抽象方法(默认为abstract和public))和属性(默认为常量 public staitc final)

              格式:

                  interface IA{

                  //不能有构造器

                  //属性必须赋值

                  String str="Hello";    //省略了public static final

                  //方法必须是抽象方法

                  void f();           //default : public final  

        为什么要使用接口?抽象类和接口如何区别,有了抽象类为什么还要使用接口?

        答：

        (1)接口不能有构造器,但是抽象类可以;

        (2)一个抽象类一次只可以被实现一个,而接口可以多个

        (3)一个抽象类可以被一个类继承,而接口可以多个

        (4)如果只有抽象类没有接口,就会导致不同设计类型无法匹配

        (5)类以后要继承其他的类,所以目前不能继承,但可以用接口

        (6)两种完全不同的类型,从逻辑上说不应该继承,但可以用接口转化成另一种类型

         

     (3)为什么要使用接口?

           (1)可插入性的保证,可以随意更换接口的实现类;

           (2)接口可以解决多重继承的问题

           sample:

            A extends B implement I1,I2,

           一个类可以转化成多种类型,继承永远只能是一种类型

           (3)接口使规范的制订者 实现者 使用者分开

               规范的制订者:国家\组织或机构对方法的特征(methodname,return type,aguments),

               负责声明抽象方法

               规范的实现者:implements

               使用者:

               分开的好处:使各个变化独立实现

  4. 接口的基本使用

      (1)实现接口的类,必须要实现其所有的方法

             具体类:全部实现

             抽象类:部分实现甚至可以不实现

             Tips:

             实现:implements

      (2)一个类可以实现多个接口

          Syntax:

          classname implements <interfacename1,interfacename2>;

        

      (3)一个接口可以继承另外一个接口,并且可以多个,还可以多重继承

      (4)接口可做类型的声明,支持类型转换(Casting)

      sample:

         IA a;

         a=new AImpl;

      (5)接口定义在另外的一个类或者接口里

      (6)接口的常用的用法

        1) 常量接口:public static final,直观 方便 代码精简

        2) 标识接口:没有任何的方法的空的接口:唯一的作用就是用来标识类型

5. 接口与抽象类的区别

      1) 接口没有任何的实现,而抽象类它可以有部分的实现也可以没有;

      2) 如果需要复用或者共享部分代码,应该用抽象类而不是接口;

      3) 继承无法解决类型的转换问题,接口就是为了解决这一问题而产生的

      (Java的单继承是接口产生的根本原因) 接口是一种抽象的第三方规范,跟对象没什么直接关系。

     6．访问控制:

     （1）包的作用

  A.区别同名的 类

        B.访问控制

        C.组织类

   （2）import

      A. 一个类要使用其他包中的类,需要引入

      B. "*"可以引入包中的所有的类,但不会引入子包

      C. 引入包是,引入到类名

   D.位置

 

7．Object中的方法

     (1) equals()

     (2)toString()

     (3)hashCode()

     (4)clone()

    

8．Inner classes

   (1)静态内部类

   (2)成员内部类

   (3)方法内部类

     1)不能用修饰符

     2)只能访问其所在方法的常量

     3)如何调用方法内部类中的方法

   (4)匿名内部类

      1)没有类名

      2)格式

      3)内部类的作用:

           封装

           多重继承

           内外部类之间可以方便地访问

           简化编程

      4)包装类:

          把基本类型转化成一个类

          转换类型的方法

          hashCode

          MIN_VALUE MAX_VALUE

          在需要将基本类型包装为一个类的时候,比如collection方法

9. Collection Framework

      一组类和接口,用来方便地管理对象

   (1)组成部分:

     Collection

     Map

     Iterator(迭代器)

     其它: Collections类

   (2)Collection

       Set

       A.无序,不允许重复元素

       HashSet

          主意自定义类,要实现equals hashCode

       TreeSet

         排序

         A.类实现Comparable接口

         B.提供一个实现Comparator接口的比较器(高优先级)

       List

       A.有序

       B.允许重复

         ArrayList

           基于数组,长度可以动态地变化

           查询的效率比较高(相对LinkerList)

         LinkerList

            基于链表实现

             插入与删除效率高

 

  Advanced Features：

  Inheritance

           The intrinsic reason of using interface is single inheritance.

使用接口最本质的原因是Java的单继承特性。

 

  Polymorphism：

可以把一个子类对象当做一个父类对象看，只能调用父类中有的属性和方法。

      如果子类覆盖了父类的方法，那么把子类对象当父类看时，调用子类覆盖后的方法。

       Animal()  eat()

       |               |

     狮子             马

   eat() 吃肉          eat()吃草

 

   左边：把它当什么看，右边：对象本身

 

  什么时候可以强转：认为有可能强转时才能转。

  Animal a=new Dog();

  Dog d=a;           //编译时出错不兼容类型

  Dog d=(Dog) a;     //认为有可能对的情况才会通过编译

  Animal b=new Cat();

 

  instanceof 是用于判断一个对象是否属于某个类型，常用在强制类型转换之前。

 

1 static 修饰符：

 

  static：静态的，可以修饰：

  (1)属性：静态属性，全类公有，常叫做类变量，和具体对象无关，无多态，类名去访问，类加载的时       候初始化，像动物园动物个数。不是某个具体对象的行为。

 

  (2)方法：静态方法中只能访问类的静态成员(包括静态属性和静态方法)，非静态方法中可以

     问静态方法的属性和成员。  工具类的对象都是static的 (java。math就是工具类)

 

  (3)代码块注：初始代码块是在类中而不再任何方法之内的代码块。被static修饰的代码块称静      态代码块，静态初始代码块在类加载的时候运行一次。

 

2 变量：

  局部变量

  实例变量  非静态    属性

  类变量    静态      属性

3 类加载：虚拟机从磁盘上将字节码文件中的内容通过I/O流读到内存的过程。在虚拟机的生命周   期中一个类只被加载一次，什么时候加载什么时候运行。类的对象在类加载的时候被创建。 注：   Java命令的作用是启动JVM。

 

4 final修饰符，可以修饰：

  (1)属性：表示这个属性的值不可变。  例：身份证号 赋值时间两种：

          在定义时赋值，一般和static合用，不加也相当于static， 加上static省空间

          在构造方法中赋值，每个对象的值可以不一样。但值给定了，就不能变。

  (2)方法：表示这个方法不能被覆盖

  (3)类：表示这个类不能被继承。

  (4)方法中的局部变量：局部变量值不可变，常量。

 

5 abstract： 抽象的，可以修饰：

 

  (1)方法：只有定义，没有实现， public abstract void move();  //用分号代替一对大括号

  (2) 类：含抽象方法的类必须是抽象类，但抽象类不一定含抽象方法。

 

  抽象类不能实例化，即不能构造对象不能new。   Animal a1 =new Animal()  //error!!!

  抽象类可以定义引用。让子类覆盖，抽象类作用，就是让子类继承。构造方法不能抽象。

 

  注意：abstract不能和final 合用

 

6 接口 interface：一个特殊的抽象类

 

  使用接口不能理解成继承接口，而应该理解为实现接口，关键字：implements

  接口里的属性都是公开静态的属性;方法都是公开的抽象方法。接口没有构造方法。

 

  例1：  abstract  class  Myclass{            例2： interface IA{

   public static final int A=10;              int  A=10;

   public static final int B=20;              int  B=20;

   public abstract void m1();                 void m1();

           public abstract void m2();                 void m2();

     }                                            }

   例1 和 例2 是等价的。

 

  接口和接口间存在继承关系，接口之间可以多继承，之间用逗号隔开。

  一个类在继承另外一个类时还可以实现接口，要先写继承后写实现。

  class1 extends class2

  class implements interface1

  interface extendsinterface1

 

  把接口当成功能模块，标准

  标准的制定者和标准的实现者分开。

 

7 对象相等判断：equals方法

   写equals方法原则：

  (1) 满足自反性  a.equals(a) 必须为真

  (2) 传递性  a.equals(b)  b.equals(c) ->  a.equals(c) 为真

  (3) 对称性  a.equals(b) 为真， 那么b.equals(a) 为真

  (4) 一致性  对象属性不改变时，返回值要一致。

 

      毫无意义的灌水

发广告帖

恶意辱骂他人

传播病毒

帖子涉嫌版权问题

讨论或传播软件破解信息

重复发帖

空

 

引用 回复

                                             Chapter 07

                                Advanced language Feature

 

 

Static Class Variables

Static Methods

静态方法不需要实例就可以调用。

类、静态方法不能访问非静态成员。

静态方法不能被非静态方法覆盖。

Static Initiation Block

静态代码块在创建对象的时候就已经初始化，而实例代码块是在程序运行的时候才起作用。

Exceptions

一、什么是异常？

1.Definition

JVM将程序运行中的不正常情况的现场信息打包成一个对象（异常类对象），并且将此对象抛出，交由相应的方法或者对象来处理。

Advanced Feature

1.发生错误以后会抛出一个异常对象

2.异常记录了：错误的原因

             指出了错误的位置，打印了错误的“栈”信息（异常使用方法调用栈结构），异常处理的机制是“责任链”机制，即子类取默认值，不处理，则交由父类处理，直至追究到JVM，然后抛给用户。

2.Syntax

 

二、为什么要处理异常？

最本质的原因是让程序能执行完毕。

对待异常最基本的处理：

无论出现什么异常，必须采取措施，想方设法让程序执行完毕。

 

三、Syntax

getMessage();

PrintStackTrace();

Advance Feature:

Error、Exception是Throwable的子类

Error：错误，程序运行中发生的系统异常，此种异常当前程序一般无法解决。

如何捕获异常：

try…catch()语句可以捕获异常。

catch（）可以没有，不过一定要接finally语句。

Syntax：

try{

    code which may make a mistake

}

catch（possible exception type<options>）{

body of method

}

受查异常：编译器强迫必须捕获并处理的异常

非受查异常：对于此种异常，编译器不要求捕获

为什么非受查异常编译器不要求捕获？

1.low-grade mistake，程序员完全可以避免的错误；

2.当错误发生是你捕获异常也无济于事

Exception包括RuntimeException与受查异常，其他为非受查异常。

 

四 处理异常

1.Exception type:抛出异常或者该异常的父类;

2.测试代码在try与catch()语句之间

step1:将有可能出错的代码放在try...catch()语句之间

step2:在catch()中捕获异常,异常类型可以声明是其父类

step3:在catch()中处理异常

 

五 如何处理异常

1.交给自己处理,交由当前方法处理

2.交给别人处理,由调用该方法的方法来处理

3.自己处理一部分,然后调用系统的异常方法

交给调用方法的处理步骤:

step1:在方法后申明可能出现的异常(throws Exception type)

step2:该方法不用再作其它异常处理

step3:调用方法必须处理被调用方法申明的异常

Tips:

   被调用方法声明的异常类型不能小于调用方法声明的异常类型

对于throw,注意事项:

(1)throw抛出的异常可以是另外一种类型的异常

为什么要throw的抛出异常类型要进行异常转换?

   首先,throw抛出的异常类型可以是throw抛出的异常类型的同类和其父类;

   其次,如果程序员throw抛出的异常类型转换为其父类,目的是进行异常处理;

   更深一个层次,抛出的异常类型为父类,然后进行异常处理包括:

       写入日志文件,

       对异常采取措施使程序能够执行完毕,而不是throw,

       向后台发送讯息,

       打印异常信息(比如BLException)

      

    不要放过被捕获的异常,捕获的异常如果不处理就会被抛出.  

  

此时throws声明声明的异常应该是抛出异常,throw异常和throws异常类型应该保持一致

(2)throw语句后不能再有其他代码,throw后面的代码永远不会被执行

 

六 多重异常

在try...catch()语句中可能不只抛出一个异常,但是每一时刻只能抛出一种异常.

Syntax:

try{

   }catch(Exception type1){

   method body1

   }catch(Exception type2){

   method body2

   }

 

   多重异常处理应注意的问题:

   (1)对可能抛出的每一种异常分别用catch()来处理

   (2)catch()语句处理多重异常应该遵从从子类到父类的顺序?

   为什么?

   多重异常是多个异常的集合,如果异常A是异常B的父类,那么先处理了异常A,就不可能抛出子类的异常.

   (3)多重异常也可以用多种异常的父类型来处理

      声明异常的父类来抛出异常可以用instanceof来判断异常类型,然后处理各类捕获的异常

      未捕获异常:异常捕获遗漏的异常.

     

七 finally

   用于资源的释放,一般用在异常处理语句

   finally的使用:

   (1)finally用于资源的释放

   (2)在异常处理当中,finally语句一定会被执行

   (3)finally语句中如果有return语句,正常运行先执行finally,再执行return语句返回.   

     当异常发生时,先执行catch语句捕获异常.如果没有catch语句,则执行finally语句以及其他语句.

   (4) try语句后面一般接catch语句,然后没有catch语句,一定有finally语句.

   (5) finally当中的return语句会overload正常的返回结果,并且有可能丢失异常.

   因此不要在finally语句中使用return语句.

   （6）finally语句中，方法可以被overload，但不可以override。

八 自定义异常

   1.为什么要自定义异常?

   (1)Java程序员可以定义更多的方法来处理异常

   自定义异常类能提供更复杂更详细的方法,这样能极大地加强软件的健壮性

   比如BLException:用一个异常的功能号来找到异常信息

   (2)代码更加清晰

   2.怎样自定义异常?

   方式1:继承 Exception

   方式2:继承 RuntimeExceptiom

  

九 在Override 构造器中处理异常需要注意的问题

   在方法override时如果父类方法声明的异常是运行时异常,则子类可以声明声明更多的异常.

   非受查异常:NullpointException

             ArithmeticException

             NumberFormatException

             NagtiveArrayException

             SecurityException