Java 私塾第三、四章笔记整理

luodis 发布于 2011/01/18 09:15
阅读 214
收藏 2

Java 私塾第三、四章笔记整理

一.面向对象初步

二.面向对象三大特征:

    1.封装:把对象的全部属性和全部服务结合在一起,形成一个不可分割的独立单位;尽可能隐藏对象的内部结构。

同一个类中 同一个包中 不同包中的子类对象 任何场合
Private Yes      
Default Yes Yes    
Protected Yes Yes Yes  
Public Yes Yes Yes Yes


    2.继承:如果一个对象A继承自另一个对象B,就把这个A成为B的子类对象,而B成为A的父类对象。继承可是子对象具有父对象的各种属性和方法,而不需要再次编写相同的代码。同时,可以重新定义某些属性,并重写某些方法,即覆盖父对象的原有属性和方法,使其获得与父对象不同的功能。
    3.多态:同一种行为的多种不同表达,或者同一种行为的多种不同实现就叫做多态。

三.JAVA类的基本构成

    包:包是类接口或其他类的集合,包主要用来将类组织起来成为组,从而对类进行管理
    (1)允许将包含类代码的文件组织起来,易于查找和使用适当的类
    (2)包不止是包含类和接口,还能包含其他包。形成层次的包空间。
    (3)有助于避免命名冲突。

        JDK中常用的包:java.lang---包含一些java语言的核心类,包含java语言设计基础的类。Object类是所有类的基类。
                       java.awt---包含构成抽象窗口工具集(abstract window toolkits)的多个类,这些类被用来构建和管理应用程序的图形用户界面(GUI)。
                       java.swing---定义java版的图形用户界面(GUI)解决方案,提供了很多完备的组建,可以对复杂的桌面系统构建。
                       java.net---包含执行于与网络相关的操作的类。
                       java.io---提供多种输入输出功能的类。
                       java.util---包含一些实用工具类,如定义系统特性,使用与日期日历相关的方法。还有重要的集合框架。

    每个源文件只有一个包的声明,而且包名应该全部小写。

    编译和生成包

    带包编译: javac –d destpath Test.java
               javac –d c:\test\ Test.java
    带包运行:java p1.Test

java类搜索方式:import语句引入p1包内的Test类,假定环境变量CLASSPATH的值为,“.;  c:jdk\lib; d:\ex”,java运行环境将依次到下述可能的位置寻找并载入该字节码文件 Test.java
.\p1\Test.java
C:jdk6\lib\p1\Test.java
D:\ex\p1\Test.class

    构造方法:创建对象并初始化成员变量。创建对象时会自动调用类的构造方法。
    定义规则:必须与该类具有相同的名字,并且没有方法的返回类型(包括没有void)。一般构造方法都用public类型来说明,这样才能在程序的任意位置创建类的实例对象。
    说明:每个类至少有一个构造方法。如果不写构造方法,java编程语言将提供一个默认的,该构造方法没有参数,而且方法体为空。如果一个类中已经定义了构造方法,则系统不再提供默认的构造方法。
    析构方法:析构方法finalize的功能是:当对象被从内存删除时,该成员方法将会被自动调用。

    带参数的方法被调用:先分配形参空间,然后将实参复制给形参。

参数可变的方法(JDK5.0开始):

  1. public class Test{
  2.    public static int sum(int……n){
  3.       int total = 0;
  4.          for(int i=0; i<n.length; i++){
  5.             total += n[i];
  6.          }
  7.          Return total;
  8.    }
  9.    Public static void main(String [] args){
  10.       System.out.println(Test.sun(10,100,1000));
  11.    }
  12. }
复制代码

四.如何使用一个java类
    this关键字:
        (1)点去成员;
        (2)区分同名变量;
            “this.变量”调用的是当前属性的变量值,直接使用变量名称调用的是相对距离最近的变量值。
        (3)作为方法名来初始化对象;
           相当于调用本类的其他构造方法,他必须作为构造方法的第一句。

五.引用类型

  1. public class TempTest {
  2.    private void test1(A a){
  3.       a.age = 20;
  4.       System.out.println("test1方法中的age="+a.age);
  5.    }
  6.    public static void [/color][/b]main(String[] args) {
  7.       TempTest t = new TempTest();
  8.       A a = new A();
  9.       a.age = 10;
  10.       t.test1(a);
  11.       System.out.println("main方法中的age="+a.age);
  12.    }
  13. }
  14.    class A{
  15.       public int age = 0;
  16. }
复制代码

运行结果:
    test1方法中的age=20
    main方法中的age=20

【此处有图片,可以到java 私塾官网下载完整笔记:www.javass.cn

六.变量

在方法外定义的变量被自动初始化,局部变量必须在使用前“手工”初始化。

七.包装类

基本数据类型 对应的包装类
boolean Boolean
byte Byte
short Shor
int Integer
long Long
char Character
float Float
double Double



       Integer t = new Integer(i);           包装,装箱
       Int j = t.intValue();    //j=500      拆箱

八.类型转换

    强制类型转换:
    强制类型转换只能用在原本就是某个类型,但是被表示成了另外一种类型的时候,可以把它强制转换回来。强制转换类型并不能在任意的类型间惊醒转换。

    变量可自动被升级为一个较长的形式。
    byte—--short--—char--—int--—long--—float----double


    自动包装和解包
    自动包装:把基础数据类型自动封装并转换成对应的包装类的对象。
    自动解包:把包装类的对象自动解包并转换成对应的基础数据类型。
              Integer a1=5;   //自动包装
              Int a2 = new Integer(5);    //自动解包

    强制类型转换:在一个类型前面加(),来强制转换
            long l = 9L;
            int i = (int)l;
    自动类型转换:
            int i = 5;
            String str = ""+i;
    向上造型:把范围小的造型为范围大的类型,
            int i = 2;
            long l = i;

九.什么是实例变量?什么是局部变量?什么是类变量?什么是final变量?

    实例变量:类中定义的变量,即类成员变量,如果没有初始化,会有默认值;
    局部变量:在方法中定义的变量,必须初始化;
    类变量:用static可修饰的属性;
    final变量: final属性只允许赋值一次,且只能通过构造方法赋值;定义后也就是一个常量。

    定义规则和使用规则
    实例变量:它不需要static关键字来声明,只要对象被当作引用,实例变量就将存在;
    局部变量:在方法内任意定义变量即为局部变量;
    类变量:必须用static修饰;
    final变量:不可以再修改的。


第四章 高级类特性

一.Java中的继承

    有继承的类在运行的时候,一定要记得:初始化子类必先初始化父类。
    初始化一个类,必先初始化它的属性。
    单继承性:当一个类从一个唯一的类继承时,被称做单继承性。单继承性使代码更可靠。
    尽管一个子类从父类继承所有的方法和变量,但他不继承构造方法。

    关键字super
    super可被用来引用该类的父类,他被用来引用父类的成员变量和方法。
    Super关键字的功能:(1)点取父类中被子类隐藏了的数据成员
                       (2)点取已经覆盖了的方法
                       (3)作为方法名表示父类的构造方法
        无论是super 还是this都必须放在构造方法的第一行。
        定义一个带参数的构造方法,并用这些参数来控制一个对象的父类部分的构造。可通过从子类构造方法的第一行调用关键字super调用一个特殊的父类构造方法作为子类初始化的一部分。要控制具体的构造方法的调用,必须给super()提供合适的参数。当不调用带参数的super时,缺省的父类构造方法被隐含地调用。在这种情况下,如果没有缺省的父类构造方法,将导致编译错误。

二.方法的覆盖和重载
    方法的覆盖
    在类继承中,子类可以修改从父类继承来的行为,也就是说子类能创建一个与父类方法有不同功能的方法,但具有相同的:名称、返回类型、参数列表。
    如果在新类中定义一个方法,其名称、返回类型及参数表正好与父类中方法的名称、返回类型及参数相匹配,那么,新方法被称做覆盖旧方法。
    调用规则:编译时看数据类型,运行时看实际的对象类型(new操作符后跟的构造方法是哪个类的)。一句话:new谁就调用谁的方法。

    覆盖方法的规则:
            (1):覆盖方法的返回类型、方法名称、参数列表必须与它所覆盖的方法的相同。
            (2):覆盖方法不能比它所覆盖的方法访问性差(即访问权限不允许缩小)。
            (3):覆盖方法不能比它所覆盖的方法抛出更多的异常。

    方法的重载
    在同一个Java 类中(包含父类),如果出现了方法名称相同,而参数列表不同的情况就叫做重载。
    参数列表不同的情况包括:个数不同、类型不同、顺序不同等等。特别提示,仅仅参数变量名称不同是不可以的。
    跟成员方法一样,构造方法也可以重载。

三.多态

四.Static

  1. public class Test{
  2.    static UserModel um = new UserModel();
  3.    public static void main(String[] args) {
  4.         Test t1 = new Test();
  5.         t1.um.userName = "张三";
  6.         Test t2 = new Test();
  7.         t2.um.userName = "李四";
  8.         System.out.println("t1.um.userName=="+t1.um.userName);
  9.         System.out.println("t2.um.userName=="+t2.um.userName);
  10.    }
  11. }
  12. class UserModel{
  13.     public String userName="";
  14. }
复制代码

运行结果:
    t1.um.userName==李四
    t2.um.userName==李四

【此处有图片,可以到java 私塾官网下载完整笔记:www.javass.cn

     一个类中,一个static变量只会有一个内存空间,虽然后多个实例,但这些实例中的static变量会共享同一个内存空间。
     static变量是在类装载的时候就被初始化的。


     Static基本规则:
             (1)一个类的静态方法只能访问静态属性。
             (2)一个类的静态方法不能直接调用非静态方法。
             (3)如果访问权限允许,static属性和方法可以使用对象加’.’方式调用,当然也可以使用实例加’.’方式调用。
             (4)静态方法中不存在当前对象,所以不能使用this,当然也不能使用super。
             (5)静态方法不能被非静态方法覆盖。
             (6)构造方法不允许被声明为static的。

五.final

    使用规则:
    (1)final标记的类不能被继承。
    (2)final标记的方法不能被子类重写。
    (3)final标记的变量(成员变量或局部变量)即成为常量,只能赋值一次。
    (4)final 标记的成员变量必须在声明的同时赋值,如果在声明的时候没有赋值,那么只有一次赋值的机会,而且只能在构造方法中显式赋值,然后才能使用。
    (5)final标记的局部变量可以只声明不赋值,然后再进行一次性的赋值。
    (6)final 一般用于标记那些通用性的功能、实现方式或取值不能随意被改变的成分,以避免被误用。

    普通类型:字母大写,不同单词间用下划线隔开。
    引用类型:字母大写,不用下划线隔开。

六.内部类

    Java中允许一个类的内部定义另一个类,后者成为内部类。
    内部类特点:
        (1)内部类可体现逻辑上的从属关系,同时对于其他类可以控制内部类对外不可见。
        (2)外部类的成员变量的作用域是整个外部类,包括内部类。但外部类不能访问内部类的private成员。
        (3)逻辑上相关的类可以在一起,可以有效的实现信息隐藏。
        (4)内部类可以直接访问外部类的成员,可以用此实现多继承。
        (5)编译后内部类也被编译为单独的类,不过名称为outclass$inclass的形式。

    匿名内部类:

  1. public void t1(){
  2.     final int a = 15;
  3.     String a = “t1”;
  4.     new Aclass(){
  5.         public void testA(){
  6.             System.out.println(TOTAL_NUMBER);
  7.             System.out.println(id);
  8.             System.out.println(a);
  9.          }
  10.     }.testA();
  11. }
  12. public void t1(){
  13.     Class B extends Aclass{
  14.         public void testA(){
  15.             System.out.println(TOTAL_NUMBER);
  16.             System.out.println(id);
  17.             System.out.println(a);
  18.         }
  19.          new B().testA();
  20.    }
  21. }
复制代码

匿名内部类规则:
      (1):匿名类没有构造方法;
      (2):匿名类不能定义静态的成员;
      (3):匿名类不能用4 种权限、static、final、abstract修饰;
      (4):只可以创建一个匿名类实例

七. 析构方法finalize 的功能是:当对象被从内存中删除时,该成员方法将会被自动调用。     
    通常,在析构方法内,你可以填写用来回收对象内部的动态空间的代码。

加载中
0
anfield
anfield

回忆回忆,不错。

0
l
luodis

学习一下

0
游客
游客

hello world

返回顶部
顶部