java学习笔记（3）——面向对象

this关键字
this是当前对象的引用，是运行期间当前对象本身。

可以使用this明确的访问当前对象的属性或者方法，类似于“我”

this()可以调用本类的其他构造器，可以使用构造器的重用简化代码的实现

this()必须写在构造器的第一行！

一、java调用方法参照两点：


1，方法签名(方法名+参数列表)


2，就近原则：


比如  f('a',5) ---->f(int ,int)


f(double,int)


3，java参数的传递规则


基本类型：值传递


引用类型：地址传递

二、多态和重载


java使用方法的重载体现了多态的特征


Person是Student的超类


Person stud = new Student();


编译期类型为Student()运行时类型为Person()，这种现象叫动态绑定(也就是多态)


如果父类没有无参构造器，就必须在子类中明确的指定父类的有参构造器。


所以建议每个类都提供无参构造，减少继承时候的麻烦。

-------------------------------------------------------------------package pack01;

public class Persion {


private int age;


private double height;


private double weight;


Persion(int age, double height, double weight){


this.age = age;


this.height = height;


this.weight = weight;


}

}

class Student extends Persion{


private int id;


Student(int age, double height, double weight, int id){


super(age, height, weight);


this.id = id;


}

}

-------------------------------------------------------------------

三、对象实例化过程


1，创建类之前，检查类是否加载，如果没有加载，先加载父类，再加载该类。


  加载类：通过CLASSPATH找到.class文件，将硬盘上的.class文件加载到内存中


  java采用按需加载：第一次用到就加载，只加载一次。


2，在内存堆中分配对象空间。递归分配所有父类和子类属性空间。


  默认自动初始化，初始化"0"值。


3，进行属性的赋值。


4，递归调用父类的构造器。


5，调用本类的构造器。

四、访问控制修饰符


类内
包内
子类
包外


1，public  
yes
yes
yes
yes


2，protected
yes
yes
yes


3，default
yes
yes


4，private
yes

五、引用类型的转换


向下转换：小类型---->大类型  (自动转换)


向上转换：大类型---->小类型  (强制转换)

六、静态绑定和动态绑定


多态就是动态绑定


静态绑定就是在Student对象中有2个属性name，系统为了加以区分，会为同名属性加一个标签：将属性标记


为在栈内存中声明的引用变量的类型，调用具体引用变量.属性时，根据标签去找，这种现象称为静态绑定

七、javabeen规范


关于JavaBean规范：JavaBean丌是语法规范，是习惯性编程规范，用这个规范写的类使用方便。


有时候JavaBean的类也称为:POJO 类（Plan Old Java Object）

简化规范： 


1)  必须有包（package） 


2)  Java类，具有无参数构造器 


3)  有用getXxx() 和 setXxx() 声明的Bean属性 


如：getName() 和 setName(String n) 声明的Bean属性为：name, 不是否有实例变


量name无关 


boolean类型的get方法可以有两种形式：getMarried() 戒者 isMarried() 


4)  必须实现序列化接口（注：在学习IO的时候具体学习） 

 


JDK提供的类几乎都符合JavaBean规范。如：String类,  集合类 


JavaBean最大的好处：“使用方便”

八、static关键字


static关键字修饰：属性，方法，内部类，代码块。


1)  static修饰的资源属于类级别，是全体对象实例共享的资源 


2)  静态属性 


使用static修饰的属性，属于类的全体类的实例共享的变量 


静态属性是在类的加载期间初始化的 


使用类名.属性访问，如：System.out 


3)  实例变量 


属于对象的属性 


使用对象.属性访问，如：person.name

九、finally关键字


1)  final 修饰的类，不能再被继承 


Java 的String就是final类，不能被继承！（面试题可能考到） 


Math 是final类，不能被继承！ 


Integer 、Long、Character等包装类是final类，不能被继承！ 


在实际项目开发中，原则上不允许使用final类！ 


Spring, Hibernate,Struts 2, 这些框架使用了"劢态继承代理"技术，使用final的类会影


响"动态代理技术" 的实现. 


2)  final修饰的方法，不能再被覆盖 


在实际项目开发中，原则上不允许使用final方法！ 原因也是因为: 动态代理技术 


3)  final 修饰的变量，初始化以后不允许再修改了 


final 局部变量 


final 方法参数 


final 的成员变量


4)  final static -- Java使用final static修饰的变量作为常量 


一般要求常量名都有大写字母 


Java常量丌是const（c、c++中修饰常量的修饰符）


final修饰属性表示“不能改”，static修饰属性表示属于类的“仅此一份”，注意区分 


知识点： 


final的局部变量，只能初始化不能改 


final的方法参数，不能改 


final的引用，引用指向丌能改，但是对象的属性可以改

十、抽象类

十一、接口


接口中的属性，默认是常量 public static final 


接中的方法一定是public abstract的（默认，可以不写）

十二、Object类


toString() ,hashCode(), equals()


toString()方法，经常由系统默认调用，是活劢当前对象的文本描述 


Object默认返回值:  全限定名为@hashCode 


建议覆盖为：当前对象的文本描述

十三、equals方法：


用来比较两个对象是否相等的方法


比较对象分为两种：“引用相等”与“对象相等”


equals在Object类中声明，默认的比较规则是：比较引用(地址值)


建议覆盖，实现对象的比较(比较对象的状态，就是比较对象的数据)


覆盖规则：


自反性：对于任何非空引用值x, x.equals(x) 都应返回true.


对称性：对于任何非空引用值x 和 y当且仅当 y.equals(x)返回true时， x.equals(y)


才应返回true.


传递性：对于任何非空引用值 x,y 和 z,如果x.equals(y)返回true,并且y.equals(z)返回


true, 那么x.equals(z)应返回true.


一致性：对任何非空引用值x和y,多次调用x.equals(y)始终返回true或始终返回false.

十四、hashCode()方法


hashCode()方法要与equals方法一同覆盖(sun公司规定)


当两个对象的equals比较为true时，应具有相同的hashCode()值


当两个对象equals比较为false时，应具有不同的hashCode()值


hashCode()值要稳定(一致性)，一个对象创建以后就不应该再变化


默认的hashCode()值是当前堆对象地址转换的一个整数，这个整数不是内存地址！


一般使用OID值作为hashCode的值


OID是对象的唯一编号，在项目中一般采用数据库生成OID，也就是数据库中的"主键"

十五、String字符串


字符串就是字符数组


字符串和字符数组可以相互转化


String str = new String(new char[]{'1','2','3'});   //字符数组转化为字符串


char[] chs = str.toCharArray();
//字符串转化为字符数组

-----------------------------------------------------------------------

package pack01;

public class Test {


public static void main(String[]args){


String str1 = "abc";


String str2 = str1;


str1 = str1 + "efg";

System.out.println(str1);


System.out.println(str2);


}

}

该程序的内存分配过程为：


栈      
堆


str1  ----------->
"abc"


str2  ----------->
"abc"


"efg" (堆中有"abc"和"efg")


"abcefg" (堆中有"abc"和"efg"和"abcefg")


str1  ----------->
"abcefg"  (堆中有"abc"和"efg"和"abcefg")

-----------------------------------------------------------------------

十六、正则表达式


用户名规则 ^\w{8,10}$


【解释】可出现8-10个单词戒字符


电话号码 +86 13912345678


^(\+86|0086)?\s?\d{11}$ 


【解释】 "+"特殊字符，需要转义"\+"表示"加号" \+86 表示出现"\+86"这几个字符 


(\+86|0086)? 表示"+86"戒"0086"出现0-1次 \s? 表示空白(空格)出现0-1次 \d{11} 表示出现11位数字


身份证号码 ^\d{15}(\d{2}[0-9xX])?$


一个点的坐标 ^\d+(,\s*|\s+)\d+$


【解释】 \d+ 表示出现1个及以上的数字 


(,\s*|\s+) 表示出现“逗号和0个及以上的空 白”戒“1个以上的空白” \d+ 表示出现1个及以上的数字 ^\d+[,\s]\s*\d+$


答案规则(参考) ^\s*A?(\s+|,\s*)B?(\s+|,\s*)C?(\s+|,\s*)D?\s*$


【解释】 \s* 可出现0-n个空格 A? A可出现0-1次 (\s+|,\s*) 


"1个以上空白"戒"逗号，0个及以 上空白" D?\s*


日期 2011-01-30


^\d{4}-\d{2}-\d{2}$ ^\d{4}(-\d{2}){2}$


IP 地址 192.168.0.2


^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$ ^\d{1,3}(\.\d{1,3}){3}$ ^(\d{1,3}\.){3}\d{1,3}$ 


“.”是特殊字符，需要转义“\.”

十七、String和StringBuffer的区别


String = char[] + 操作(复制创建新对象)


StringBuilder = char[] + 对char[]的操作(处理当前数组内容)


区别StringBuilder内部的数组内容和长度可变。


String内部的数组内容和长度不可变。

----------------------------------------------------

----------------------------------------------------

StringBuilder


1) StringBuilder是变长字符序列


2) StringBuilder方法：append，insert ... 都返回当前 StringBuilder 对象本身的引用


3) 如果软件需要大量字符串处理时候建议使用StringBuilder


4) String s = s1+s2; Java实际上是如下代码运行：


  String s=new StringBuilder(s1).append(s2).toString();


5) String s = s1+s2+s3+s4; 被优化为


  String s = new StringBuilder(s1).append(s2).append(s3).append(s4).toString();


6) s += "a";会产生两个新对象(StringBuilder, String)（笔试题）


  StringBuilder buf=new StringBuilder(); buf.append("a"); buf.append("a");


7) StringBuffer 和 StringBuilder API几乎一样！


  StringBuffer 是java早期提供的（JDK1.0），速度稍慢，线程安全 StringBuilder 


 是Java5 以后提供的（JDK5.0），速度快，非线程安全

所以对大量的字符串拼接使用StringBuilder.

如果对字符串性能有极高的要求，就用char[]

十八、ArrayList(1.2版本以后的)是使用变长数组算法实现的，ArrayList继承自List


1，ArrayList和Vector的比较


Vector,现成安全，效率稍低，也是使用变长数组算法实现的，继承自List接口。


ArrayList,线程不安全的，效率高速度快(现在较常用)


2,ArrayList和LinckedList的比较


LinkedList是采用双向循环链表实现的List


ArrayList是采用变长数组算法实现的List

十九、散列表概念


1，容量
散列表中散列数组大小


2，散列运算
key->散列值(散列数组下标)的算法，如： "mm".hashCode()%10->8


3,散列桶
散列值相同的元素的 "线性集合"


4,加载因子 是散列数组加载率，一般小于75%性能比较理想


就是(元素数量/散列数组大小)如
如： 7/10 = 70%


5,散列查找 根据Key计算散列值，根据散列值(下标)找到


6，散列桶
在散列桶中顺序比较Key,如果一样，就返回value


散列表中Key不同，Value可以重复

二十、HashMap


在ArrayList中查找Mac，顺序查找，需要查找5次

 
在HashMap中（底层实现原理是散列表）查找Mac，经过散列运算，仅需1次