《Java核心技术一》学习笔记

三、 Java基本程序设计结构

1、如果在数值计算中不允许有任何舍入误差,就应该使用BigDecimal类

2、String 不可变字符串;

      StringBuilder 可变,所有字符串在一个单线程中编辑

      StringBuffer 可变,允许采用多线程的方式执行添加或删除字符的操作,效率较低

3、在一个源文件中,只能有一个公有类,但可以有任意数目的非公有类

4、Java中是值传递的。

     1)如果参数是基本数据类型,则是值传递,传递的是一个拷贝

     2)如果参数是一个对象引用,传递的也是一个拷贝,但这个拷贝与原对象引用指向同一个对象,所以是对该对象本身进行修改

5、局部变量一定要初始化

      域变量不初始化,会默认初始化:(0,false或null)

6、数组一旦确定了就不能改变

    但是ArrayList类能。

四、对象的行为——封装

    1、基本原则:将你的实例变量标记为私有的,并提供共有的getter与setter来控制存取动作。

            将实例变量标记为 private ; 将getters与setters标记为public

    2、任何有值可以被运用到的地方,都可用调用方法的方式来取得该类型的值。

    3、实例变量永远都会有默认值;实例变量声明在类中。

            数字的primitive预设为 0 ;boolean预设为 false ; 对象引用为 null

    4、局部变量没有默认值;局部变量声明在方法中;局部变量在使用前必须初始化。

    5、使用==来比较两个primitive主数据类型,或者判断两个引用是否同一个对象;

          使用equals()来判断两个对象是否在意义上相等。

五、超强力方法

    1、在编写方法之前,先写出测试方法用的程序代码。

    2、加强版for循环

            for(String name : nameArray){}

            第一段:声明循环变量    第二段:要运行的集合

六、认识java的API

    1、ArrayList是零基的

    2、ArrayList可用add(Int , Object) 这个形式的方法来指定索引值。

    3、ArrayList用indexOf,如果该对象未出现在ArrayList中,则返回-1

    4、import java.util.ArrayList;

七、继承与多态

    1、子类可以对父类的实例变量和方法进行覆盖(override)

    2、设计继承树步骤:

        1>找出具有共同属性和行为的对象

        2>设计代表共同状态与行为的类

        3>决定子类是否需要让某项行为(也就是方法的实现)有特定不同的运作方式

        4>通过寻找使用共同行为的子类来找出更多抽象化的机会

        5>完成类的继承层次

    3、继承调用对象的引用方法时,会调用到与该对象类型最接近的方法。

    4、判断某物是否应该要继承另一物时,可以用IS-A测试来检验。

    5、HAS-A关系表明是一个实例变量。

    6、子类可以不用完全覆盖掉父类的功能,只是再加上额外的行为。

            可以通过super这个关键词来取用父类。

   7、父类通过存取权限决定子类是否能够继承某些特定的成员。

            private        default        protected        public

          左边是最受限制的,越往右边限制越小。

            public类型的成员会被继承;private类型的成员不会被继承。

    8、使用继承的情况:当某个类比其父类更具有特定意义时使用继承。

    9、在多态下,引用于对象可以是不同的类型。

            运用多态时,引用类型可以是实际对象类型的父类。参数和返回类型也可以多态!

    10、覆盖的规则:

             1>参数必须要意义,且返回类型必须要兼容

             2>不能降低方法的存取权限

    11、方法的重载:两个方法的名称相同,但参数不同。

    12、方法的重载规则:

             1>返回类型可以不同

             2>不能只改变返回类型

             3>可以更改存取权限

八、接口与抽象类

    1、接口:是一种100%纯抽象的类

    2、抽象类:是无法初始化的类,不能创建任何类型的实例。

    3、抽象的类代表此类必须要被extends过,抽象的方法代表此方法一定要被覆盖过。

    4、抽象的方法没有实体!没有方法体,直接以分号结束。

                public abstract void eat();

    5、声明处一个抽象的方法,就必须将类也标记为抽象的。不能再非抽象类中拥有抽象方法。

    6、Object是所有类的源头,是所有类的父类。

    7、Object类的主要目的:1.作为多态让方法可以应付多种类型的机制

                                              2.提供Java在执行期对任何对象都有需要的方法的实现程序代码

    8、任何从ArrayList取出的东西都会被当做Object类型的引用而不管他原来是什么

    9、Object自带方法:1.equals()  2.getClass()  3.hashCode()  4.toString()

    10、致命方块:子类a、b继承c并覆盖方法go,d继承a和b,调用方法go出现问题

    11、接口:关键词interface,解决多重继承引起的致命方块问题。

                      把全部的方法设为抽象的!即100%的抽象类

    12、extends只能有一个,implements可以有好多个

    13、关键词super :要创建出一个具体的子类且必须要覆盖某个方法,但又需要执行父类的方法的情况。

九、构造器与垃圾收集器

    1、对象存在于可垃圾回收的堆上,实例变量存在于所属对象的堆空间上

          方法调用及局部变量存在于栈上,生命周期只限于方法被放在栈上的这段期间

    2、栈顶上的方法时目前正在执行的方法

    3、primitive主数据类型和对对象的引用变量仍然会放在栈上,对象本身只会存在于堆上

    4、当对象中带有另一个对象时,会留下空间给引用变量的值,但引用变量不是对象本身

    5、创建对象的步骤: 1.声明引用变量  2.创建对象  3.连接对象与引用

    6、构造函数没有返回类型,方法有返回类型

    7、将初始化的程序代码放在构造函数中,然后把构造函数设定成需要参数的

    8、如果已经写了一个有参数的构造函数,并且需要一个没有参数的构造函数,必须再写一个无参构造函数

    9、重载构造函数的参数不能相同,编译器根据参数的类型和顺序判断

    10、构造函数规则:1>构造函数是在新建类时会执行的程序

                                     2>构造函数必须与类的名字一样,且没有返回类型

                                     3>如果没有写构造函数,编译器会写一个没有参数的

                                     4>一个类可以有很多个构造函数,但不能有相同的参数类型和顺序,叫做重载过的构造函数

    11、在创建新对象时,所有继承下来的构造函数都会执行

    12、构造函数中调用父类构造函数的唯一方法时调用super()。

            如果没有调用super(),编译器会帮我们加上super()的调用,该super是无参的

            super()是构造函数执行的一条语句,必须放在最前面

    13、使用this()来从某个构造函数调用同一个类的另外一个构造函数。

            this()只能用在构造函数中,且它必须是第一行语句!

    14、每个构造函数可以选择调用super()或this(),但不能同时调用!    

    15、生命周期:1.局部变量只会存活在声明该变量的方法中

                               2.实例变量的寿命与对象相同。如果对象还活着,则实例变量也会是活的

    16、当最后一个引用消失时,对象就会变成可回收的。

            三种方法:1.引用永久性的离开它的范围

                              2.引用被赋值到其他的对象上

                              3.直接将引用设定为null

十、数字与静态

    1、Math类中的所有方法都不需要实例变量值。

           因为这些方法都是静态的,所以无需Math的实例,会用到的只有它的类本身

    2、关键词static :可以标记处不需类实例的方法

    3、静态方法没有对象

    4、静态方法:以类的名称调用静态的方法

          非静态方法:以引用变量的名称调用非静态的方法

    5、静态的方法不能调用非静态的变量,也不能调用非静态的方法

    6、静态变量的作用:被同类的所有实例共享的变量

    7、静态变量会在该类的任何静态方法执行之前就初始化

    8、如果没有给静态变量赋值,会被设定默认值,即该变量类型的默认值

    9、静态final变量初始化后会一直维持原值,必须初始化

    10、常数变量的名称应该要都是大写字母!

    11、静态初始化程序 static{ },再类被加载时执行

    12、final的变量代表不能改变它的值;final的方法代表不能覆盖掉该方法;final的类代表不能继承该类

    13、Integer、Character是对象,int、char是primitive主数据类型

    14、String转primitive主数据类型:  int x = Integer.parseInt(string)

            primitive主数据类型转String: String s = Double.toString(double)

    15、String s = String.format("%,d",1000000000);    有逗号的数字格式 1,000,000,000

    16、String.format唯一必填项目是类型

    17、日期格式的类型是用“t”开头的两个字符来表示

              完整的日期与时间:%tc  ;只有时间:%tr  ;周、月、日:%tA%tB%td

              Date today = new Date();

              String.format("%tA, %

    18、要取得当前的日期时间就用Date,其余功能可以从Calendar上面找

    19、取得继承过Calendar的对象

            用这个静态方法: Calendar cal = Calendar.getInstance();


十一、异常处理

    1、如果一个方法的声明有throws语句,则会抛出异常,需要异常处理    

    2、Exception类型的对象可以是任何它的子类的实例

    3、1> 有风险、会抛出异常的程序代码:

public void takeRisk()throwsBadException{

                    if(abandonAllHope){

                            thrownew BadException();

                    }

}

            2>调用该方法的程序代码:

public void crossFingers(){

    try{

        anObject.takeRisk();

    }catch(BadException ex){

        System.out.println("Aaargh!");

        ex.printStackTrace();

    }

}

    4、编译器不会注意RuntimeException类型的异常

    5、finally块是用来存放不管有没有异常都得执行的程序    

    6、如果try或catch块有return指令,finally还是会执行!先跳到finally然后再回到returnzhiling     

    7、方法可以抛出多个异常

    8、异常时对象,也能够以多态的方式来引用

    9、有多个catch块时要从小排到大

    10、duck掉:把method声明成跟有风险的调用一样会抛出相同的异常   

    11、try一定要有catch或finally,只带有finally的try必须要声明异常

    12、Message是执行的内容 ; MidiEvent是执行的时机


十二、图形用户接口

    1、监听接口是介于监听(你)与事件源(按钮)间的桥梁

    2、接口的规则:要实现接口就得声明这件事,把接口中所有的方法都实现出来

    3、再每个Grahpics引用的后面都有个Grahpics2D对象,要将其转换为Graphics2D

    4、内部类可以使用外部所有的方法与变量,就算是私用的也一样。

            内部类把存取外部类的方法和变量当做是自家冰箱

    5、内部类的实例一定会绑在外部类的实例上


十三、Swing   

    1、几乎所有的GUI组件都来自于java.swing.JComponent

    2、布局管理器(Layout Managers)是一个与特定组件相关联的Java对象,它大多数是背景组件

    3、框架默认的布局管理器:BorderLayout ; 面板默认的布局管理器:FlowLayout    

    4、布局管理器会询问每个组件理想的大小,然后以它的布局策略来决定是否应该要尊重全部或部分的理想

    5、West或East区,宽度可以自己决定,高度受布局管理器控制;

          North或South区,情况恰好相反 ; Center区只能捡剩下的

        南北先占位,东西高度还要扣除南北的高度,中央大小要看扣除周围后还剩下什么

    6、当某个组件加到背景组件上时,被加入的组件时由背景组件的布局管理器管理的

    7、Swing组件:JTextField、JTextArea、JCheckBox、JList


十四、序列化和文件的输入/输出

    1、1>只有自己写的Java程序会用到这些数据

            用序列化: 将被序列化的对象写到文件中。然后就可以让你的程序去文件中读取序列化的对象并把它们展开回到活生生的状态

            2>数据需要被其他程序引用

            写一个纯文本文件。用其他程序可以解析的特殊字符写到文件中。例如写成用Tab字符来分隔的档案以便让电子表格或数据库应用程序能够应用

    2、当对象被序列化时,被该对象引用的实例变量也会被序列化。切所有被引用的对象也会被序列化

    3、在需要被序列化的类后,加上 implements Serialization接口,表明放在此处的对象都必须实现序列化

    4、序列化是全有或全无的

    5、如果某实例变量不能或不应该被序列化,就把它标记为transient(瞬时)的

    6、一个不能序列化的类,可以将其子类标记为可序列化

    7、当把某个对象序列化后,被标记transient的实例变量会返回null

    8、解序列化(Deserialization)是序列化的反向操作    

    9、解序列化不包括transient的变量,不是null就是primitive主数据类型的默认值

    10、静态变量不会被序列化,只会维持类中原本的样子,而不是存储时的样子

    11、在对象被序列化后,类有了不同的serialVersionUID,则还原操作会失败

    12、用BufferedReader将FileReader链接起来,能够提高效率


十五、网络与线程

    1、Socket是个代表两台机器之间网络连接的对象

    2、Socket连接的建立代表两台机器之间有对方的信息,包括网络地址和TCP的端口号

    3、TCP端口只是一个16位宽、用来识别服务器上特定程序的数字

    4、从0~1023的TCP端口号是保留给已知的特定服务使用

    5、InputStreamReader是底层和高层交流的桥梁

    6、用BufferedReader从Socket上读取数据;用PrintWriter写数据到Socket上

    7、Runnable类,是对线程要执行任务的定义

    8、建立Thread对象(执行工人)并赋值Runnable(任务)

            Thread myThread = new Thread(threadJob)

    9、Runnable这个接口只有一个方法:public void run()

    10、一旦线程进入可执行状态,它会在可执行与执行中两种状态中来来去去,同时也有另外一个状态:暂时不可执行(阻塞状态)

    11、如果想要确保其他的线程有机会执行的话,就把线程放进睡眠状态

                    Thread.sleep(2000)

    12、线程的并发性问题会引发竞争状态,竞争引发数据的损毁

    13、synchronized关键词修饰符可以防止两个线程同事进入同一对象的同一方法

    14、同步化的目标是保护重要的数据

    15、Java没有处理死锁的机制

    16、sleep()方法要包含在try/catch块,可能会抛出InterruptedException

你可能感兴趣的:(《Java核心技术一》学习笔记)