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

Java 私塾第三、四章笔记整理
一．面向对象初步
二．面向对象三大特征：
    1.封装：把对象的全部属性和全部服务结合在一起，形成一个不可分割的独立单位；尽可能隐藏对象的内部结构。

	同一个类中	同一个包中	不同包中的子类对象	任何场合
∵	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. 
   
2. public class Test{
   
3.    public static int sum(int……n){
   
4.       int total = 0;
   
5.   for(int i=0; i<n.length; i++){
   
6.      total += n[i];
   
7.          }
   
8.          Return total;
   
9.    }
   
10.    Public static void main(String [] args){
    
11.       System.out.println(Test.sun(10,100,1000));
    
12.    }
    
13. }

复制代码

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

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

复制代码

运行结果：
    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. 
   
2. public class Test{
   
3.    static UserModel um = new UserModel();
   
4.    public static void main(String[] args) {
   
5.         Test t1 = new Test();
   
6.         t1.um.userName = "张三";
   
7.         Test t2 = new Test();
   
8.         t2.um.userName = "李四";
   
9.         System.out.println("t1.um.userName=="+t1.um.userName);
   
10.         System.out.println("t2.um.userName=="+t2.um.userName);
    
11.    }
    
12. }
    
13. class UserModel{
    
14.     public String userName="";
    
15. }

复制代码

运行结果：
    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）外部类的成员变量的作用域是整个外部类，包括内部类。但外部类不能访问内部类的∵成员。
        （3）逻辑上相关的类可以在一起，可以有效的实现信息隐藏。
        （4）内部类可以直接访问外部类的成员，可以用此实现多继承。
        （5）编译后内部类也被编译为单独的类，不过名称为outclass$inclass的形式。

    匿名内部类：

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

复制代码

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

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

感谢楼主分享，我现在在学这个

   神级java 飘过~！