如鹏网JAVA培训笔记20晓伟整理.docx

如鹏网JAVA培训笔记20晓伟整理.docx

《如鹏网JAVA培训笔记20晓伟整理.docx》由会员分享，可在线阅读，更多相关《如鹏网JAVA培训笔记20晓伟整理.docx（26页珍藏版）》请在冰点文库上搜索。

如鹏网JAVA培训笔记20晓伟整理

写在前边的话：

2015年1月23日如鹏线上训练营第三十天

什么是格局，格局就是一个人的眼光、胸襟、胆识等心理要素的内在布局！

一个人的发展往往受局限，其实“局限”就是格局太小，为其所限。

谋大事者必要布大局，对于人生这盘棋来说，我们首先要学习的不是技巧，而是布局。

大格局，即以大视觉切入人生，力求站得更高，看的更远、做的更大。

大格局决定着事情发展的方向，掌控了大格局，也就掌控了局势。

一个人格局大了，未来的路才能宽！

如果把人生当做一盘棋，那么人生的结局就由这盘棋的格局决定。

想要赢得人生这盘棋的胜利，关键在于把握住棋局。

在人与人的对弈中，舍卒保车、飞象跳马.....种种棋着就如人生中的每一次博弈，棋局的赢家往往是那些有着先予后取的度量、统筹全局的高度、运筹帷幄而决胜千里的方略与气势的棋手。

于丹说得好“成长问题关键在于自己给自己建立生命格局”。

为何要有大的格局？

局限就是格局大小，为其所限。

在今天这个知识不断更新的世界里，我们咋不断刷新自己的知识结构，只有一点最重要，就是尽量酝酿一种大胸怀。

大境界才能有大胸怀，大格局才有作为。

继承的概念：

继承是面向对象程序设计的一个重要特征，它实现了代码的重用。

在JAVA中，通过继承可以在现有类的基础上创建新的类，新类继承原类的属性和方法。

在新类中，可以重新定义继承的方法，也可以添加属性和方法来扩展新类的概念。

Object类是JAVA中所有类的根类，使用Object对象可以创建具有通用性的程序。

●面向对象最重要的特点之一，就是可以实现对类的复用。

可以通过两种方法实现：

1.一种方法是将一个类当做另外一个类的属性（称为合成/聚合关系）

2.另外一种方法是一个类继承另外一个类。

●实现继承的类称为子类（或派生类），而被继承的类称为父类，也叫超类或基类

●通过“继承”一个现有的类，可以使用已经定义的类中的方法和变量（权限允许的前提下）。

（public/private/protected）

●类的方法和属性可以被继承，但是类的构造器不能被继承

Java类只支持单继承，不允许多继承

●一个子类只能有一个父类

●一个父类可以派生出多个子类

Object类:

●Object类是所有java类的根父类（最高父类）任何一个java的类（class）都直接或者间接继承自Object类

●如果在类的声明中未使用extends关键字指明其父类，则默认父类为Object类

Super关键字：

●应用场景：

当想要调用父类中的同名属性/方法/构造方法时，用super关键字来区分

●在java类中使用super来引用父类的成分

super.可用于访问父类中定义的属性Demo

super.可用于访问父类中定义的成员方法Demo

super（....）可用于在子类构造器中调用父类的构造器Demo

使用super注意事项：

Super只能应用在成员方法和构造方法中，不能应用在静态方法中（和this是一样的），如果在构造方法中使用

super（.....）必须放在第一行。

this（）调用重载的构造方法

super（）调用父类的构造函数

继承中的构造方法：

●子类在构造函数的过程中必须（显示或隐式地）调用其基类的构造方法，直到Object

●子类可以在自己的构造方法中使用super调用基类的构造方法

●如果子类的构造方法没有显式的调用基类的构造方法，则系统默认调用基类无参数的构造方法：

super（）

●如果子类构造方法中既没有显示调用基类的构造方法，而基类中又没有无参的构造方法（基类没有无参的构造方法是因为程序员已经重新写了基类的构造方法，系统不会再默认调用基类的无参构造方法了），则编译出错

按照顺序进行：

父类static{}，

子类static{}，

父类{}，

父类构造方法，

子类{}

子类的构造方法{}

访问修饰符：

●（普通）类的访问修饰符

public：

任何包中的类都可以访问该类

默认值：

同一个包中的类可以访问该类

●成员的访问修饰符

private：

只对本身类可见

默认值：

对同一包中的类可见

protected：

对所有子类和同包中的类可见

public：

对一切类可见

局部变量、方法形参：

不能用权限修饰符（protected/public/private）

注意：

访问成员的前提是首先能访问成员所属的类

●访问控制：

访问控制的限制程度从高到低为：

private>default>protected>public

注：

default不是一个修饰符，它只是用来表示一种不加任何修饰符时的状态

父类中的私有方法可以被父类中的方法调用,子类可以间接调用父类中的私有方法,但一般不这样做。

方法的重写：

●在子类中可以根据需要对父类中继承来的方法进行改造——方法的重写（@Override）

●重写方法必须和被重写方法具有相同的方法名称（大小写敏感）、形式参数列表和返回值类型

●重写方法不能使用比被重写方法更加严格的访问权限

●父类的静态方法（static）不能被子类覆盖为非静态方法，反之亦然。

取其精华

大原则:

子类的功能应该比父类强大.

关于多态：

●静态多态也叫编译时多态，通过方法重载实现

●动态多态也叫运行时多态，通过对象的多态性实现

面向对象的三大特征：

封装、继承、多态

多态——在java中，子类的对象可以代替父类的对象使用

一个引用类型变量可能指向（引用）多种不同类型的对象

Personp=newStudent（）;

Objectm=newPerson（）;

m=newStudent（）;

一个引用类型变量如果声明为父类的类型，但实际引用的子类对象，那么该变量就不能再访问子类中新增加的属性和方法。

多态的第一种主要形式:

父类的引用指向了子类的对象.

Studentm=newStudent（）;

m.school=“pku”//合法

Persone=newStudent（）;

e.school=“pku”；//非法

虚方法调用：

（virtualMethodInvocation）

●正常的方法调用

Persone=newPerson（）;

e.getInfo（）;

Studente=newStudent（）;

e.getInfo（）;

●虚方法调用（多态情况下）

Persone=newStudent（）;

e.getInfo（）;//调用了在Student类中重写的getInfo方法

●方法声明的参数类型为父类类型，可以使用子类的对象作为实参调用该方法

Java大原则之三——最佳匹配性原则

println（String）;

println（Object）;

Instanceof操作符：

instanceof左边的引用指向的对象的实际类型

是不是右边的类型（或其子类类型）

对象造型（Casting）：

●对java对象的类型转换称为造型

在造型前通常使用instanceof操作符测试一个对象的类型

从子类到父类的类型转换可以自动进行

从父类到子类的类型转换必须通过造型（强制类型转换）实现

子类的对象可以当做基类的对象来使用称向上转型，反之称为向下转型

无继承关系的引用类型间的转换是非法的

多态的第三种主要形式:

声明的返回值类型为父类类型,实际返回的是子类对象的地址

例如Collection接口中有一个iterator（）方法,声明的返回值类型是一个遍历器接口类型iterator的对象

java.util.Calendar抽象类中定义的publicstaticCalendargetInstance（）;返回的实际是Calendar的子类GregorianCalendar的对象（地址）

toString（）方法：

1.Object类中定义有publicStringtoString（）方法，其返值是String类型，描述当前对象的有关信息。

默认情况是打印的是：

类名@hashcode的十六进制表示

2.在进行String与其他数据的连接操作时（如：

System.out.println（“info”+person）），将自动调用该对象类的toString（）方法。

3.可以根据需要在用户自定义类型中重写toString（）方法。

Object类的方法：

inthashCode（）方法,返回该对象的哈希码值。

ClassgetClass（）方法，返回此Object的运行时类

Integer类:

 StringtoString（）

返回一个表示该Integer值的String对象。

static StringtoString（int i）  

 返回一个表示指定整数的String对象。

static StringtoString（int i,int radix）

用第二个参数指定的基数返回第一个参数的字符串表示形式。

Objet类的方法：

inthashCode（）方法

返回该对象的哈希值

ClassgetClass（）方法

返回此Object的运行时类

==操作符：

●相同的字符串常量相等

●两个Integer,如果其中至少一个是new出来的，则不相等；如果都是同一个常量赋值的，则相等。

●基本数据类型和封装类会拆箱比较数值

●两个不同封装的对象不能比较，编译报错

●两个不同的基本数据类型，如果可以自动转换，则可以比较。

●有继承关系的引用数据类型对象之间可以比较，当指向同一个对象的时候相等。

●没有继承关系的引用数据类型不能比较

equals方法：

●在Object类中定义的equals方法：

publicbooleanequal（Objectobj）

注意：

形参是Object类型。

●调用equals（）方法时的实参可以是基本数据类型，java会自动进行装箱。

==操作符与equals方法：

1.在比较引用数据类型时，==操作符与equals（）作用完全一样——看引用的是不是同一对象

2.除非在自定义的类中重写了equals方法，或是下面的四类已经重写了equals方法的特例：

java.io.File;

java.lang.String;

Java.util.Date;

封装类

注:

比较字符串时,尽量不要用==操作符,而用equals（）方法

这四类当用equals（）方法进行比较时，只比较类型及内容而不看引用的是不是同一对象。

关键字final：

●在java中声明类、属性和方法时，可以使用final修饰符来修饰。

●final标记的类不能被继承

●final标记的方法不能被子类重写

●final标记的变量（成员变量或局部变量）即成为常量，只能赋值一次，且在使用前必须被赋值。

●final标记的方法的形参不能被重新赋值

●final标记的成员变量必须在声明的同时或在每个构造方法（或构造语句块）中显示赋值，然后才能使用

●构造方法不能使用final来修饰，因为构造方法不能被继承，更无所谓重写，用final修饰没有意义，编译会报错。

final类里面可以定义final方法

抽象类：

●应用场景：

在定义一个类时，有些方法暂时还不知道该怎么实现，只能等子类把这些方法都实现后才能使用。

●这样的方法应该定义为抽象abstrct方法

●含有抽象方法的类必须定义为抽象abstrct类

用abstract来修饰类或方法

abstractclassAbstrctClass{.....}

abstrctreturnTypeabstrctMethod（[paramlist]）;

抽象类不能被实例化，抽象方法必须被全部重写后，才能生成它的子类对象。

如果一个子类没有实现抽象类中所有的抽象方法，则子类也要声明为一个抽象类。

抽象类不一定包含抽象方法——不想让人直接实例化

可以声明抽象类类型的引用，把它作为方法形参，返回值类型等。

java.awt.event.MouseAdapter

publicabstractclassMouseAdapterimplementsMouseListener,MouseWheelListener,MouseMotionListener{

...

publicvoidmouseClicked（MouseEvente）{}

publicvoidmousePressed（MouseEvente）{}

publicvoidmouseReleased（MouseEvente）{}

publicvoidmouseEntered（MouseEvente）{}

publicvoidmouseExited（MouseEvente）{}

....

}

抽象方法和抽象类：

●在类中没有实现的方法就是抽象方法，抽象方法没有方法体（不同于方法体为{}）

接口：

●接口（interface）是抽象方法和常量值的而一个数据结构。

●从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义，而没有方法的实现[jdk8之前]

●jdk8之后，接口中可以定义default方法（一种实例方法），

static方法.publicinterfaceRunner

{

//没有方法体

intid=1;

voidstart（）;

publicvoidrun（）;

abstractvoidstop（）;

}

publicclassPersonimplementsRunner

{

//必须把接口中的方法全部进行实现

publicvoidstrat（）

{

//弯腰、蹬腿、瞪眼、开跑

}

publicvoidrun（）

{

//摆动手臂、维持直线方向

}

publicvoidstop（）

{

//减速直至停止、瘫倒、吐血、送医院

}

}

●多个类可以实现同一个接口

●一个类可以实现多个接口

●与继承关系类似，接口与实现类之间存在多态性

接口特性：

●接口可以多重实现

●接口中声明的属性默认为：

publicstaticfinal的

也必须是：

publicstaticfinal的

可以写public的或者不写，不能写private的或者protected的

●接口中只能定义抽象方法，而且这些方法默认为:

publicabstract的、也必须是publicabstract的。

可以缺省，但不能用其它修饰符；

●接口可以继承若干个其它的接口，并添加新的属性和抽象方法

●接口里可以没有任何属性，方法。

用实现接口的方式，你可以用接口中的方法指定一个类（其实现类）“必须做什么”而不是规定它“如何去做”

接口和抽象类：

●子类继承抽象类就不能再继承其他类（java的单继承原则），所以有抽象方法时优先使用接口定义。

●如果所有方法都没有实现，优先使用接口。

●一些方法已经可以实现，而另一些方法无法或不想实现时，且继承（实现）关系很简单时，考虑用抽象类定义，留给后代去实现。

jdk8之后，也可以在接口中定义default方法或static方法来实现。

内部类：

●一个类可以定义在类的内部，这样的类称为内部类，而包含它的类称为外部类（宿主类Host）

●应用场景：

处理宿主类的内部事务，一般跟其他类关系不大，能够减少java的源代码数量。

安卓阶段将大量使用匿名内部类

●内部类与外部类之间存在逻辑的所属关系

●内部类可以（直接或间接）访问外部类所有属性

●当内部类声明成public或private等时，在宿主类之外对其访问的限制与对成员变量和成员方法完全相同

●innerclass一般用在定义它的类或语句之内，在外部引用它时必须给出完整的名称。

●innerclass的名字不能与宿主类的类名相同

成员内部类：

●成员内部类也叫实例内部类，即没有用static修饰的内部类

●在文件管理方面，成员内部类在编译完成之后也会产生.class文件，而文件名称则是“外部类名称$内部类名称.class”

●非静态Innerclass可以使用宿主类的静态和实例变量

在宿主类的main方法中,如果没有创建宿主类的对象,直接创建成员内部类的对象,则编译报错:

Noenclosing（正在封闭的）instanceoftype宿主类名isaccessible（可访问）.Mustqualify使...有资格theallocation分配withanenclosinginstanceoftype宿主类名（e.g.x.newA（）wherexisaninstanceof宿主类名）.

实例化成员内部类：

●在宿主类之外，例如：

Client.java中实例化成员内部类的格式：

Outerouter=newOuter（）;//创建宿主类的对象

Outer.Innerinner=outer.newInner（）;//尝试设定

Inner不同的权限，看能否成功编译

●在宿主类内部实例化成员内部类的格式：

在main方法中：

Outerouter=newOuter（）;//创建宿主类的对象

Innerinner=outer.new.Inner（）;

或者为：

Outer.Innerinner=out.newInner（）;

在非静态方法中：

Innerinner=newInner（）;//可直接创建成员内部类的对象

成员内部类：

private内部类中的private属性，在宿主类中可以访问到

privateclassInn

{

Privateinti=2;

}

在成员内部类中可以定义staticfinal的属性，不能单独用static修饰。

静态内部类：

●如果一个内部类使用static声明，则此内部类就称为静态内部类。

●在宿主类之外在权限允许时可以通过宿主类名.内部类名

来访问。

Outer.Innerinner=newOut.Inner（）;

●在宿主类内部无论是不是静态方法中，都可以直接创建该内部类的对象。

静态内部类：

●静态内部类不会持有外部类的引用，创建时可以不用创建外部类对象。

●静态内部类可以访问外部的静态变量，如果要访问外部类的成员变量必须通过外部类的实例访问。

匿名内部类的使用：

匿名内部类的使用：

1.内部类可以声明为抽象类，因此可以被其他的内部类继承

2.内部类可以声明成abstractstatic的；也可以声明为final的

3.还可以声明内部接口。

如：

java.util.Map.Entry

4.抽象内部类的宿主可以不声明成抽象类的。

工厂模式一般在是用于根据参数不同返回不同对象，

例如加载数据，从本地文件或者是网络或数据库，或从内容提供者的数据抽象，

或者是用JSONXML加载同样的Bean的不同数据格式，主要为了实现兼容性