疯狂java讲义的笔记总结1： 语法和面向对象基础

疯狂java讲义的笔记总结1：

语法和面向对象基础

引用类型的参数传递
class DataWrap
{
public int a;
public int b;
}
public class ReferenceTransferTest
{
public static void swap(DataWrap dw)
{
//这个实现了交换功能
int tmp=dw.a;
dw.a=dw.b;
dw.b=tmp;
System.out.println("swap方法里，a Field的值是"+dw.a+";b Field 的值是"+dw.b);
}
public static void main(String[] args)
{
DataWrap dw=new DataWrap;
dw.a=6;
dw.b=9;
swap(dw);
System.out.println("交换结束后，a Field 的值是"+dw.a+";b Field 的值是"+dw.b);
}
}


int 是一种值类型，其传递是无法改变实参的，但是如果你把它打包成引用型的，就可以实现参数传递。但是如果用包装类，包装类貌似是final的


最后一个形参的类型后增加...，表示可以有参数数量可变
例如：int test(int a,String... books){}


局部变量可与成员变量同名，在方法中此名的代指局部变量，用this.此名代指成员变量


变量要遵循在哪用在哪定义的原则，方便在一个方法结束后对资源进行回收。


访问控制级别
private 同一个类中。自由使用
default 同一个包中。
protected 子类中
public 全局范围


类中的Field应该通过setter和getter函数来控制（Field应该设为private，只有一些static的类似全局的，才考虑Field）


包提供了类的多层命令空间
如果我们想把一个类放在某个包底下，那么源码的第一行
package packageName;
... class hello...
在命令行下用
javac -d . hello.java//-d这个参数是设定class文件的保存位置
java规定包中类最好在包名的目录下
如果项目够大，还可以在包下以项目名建立子包，在项目名子包下还可以以模块名建立模块子包。跨包使用类的话要加前缀（包名加类名），会很麻烦，故引入import这个关键字。一个源文件最多只能有一个package packageName;使用import package.subpackage...ClassName;
或import package.subpackage...*;(注意*只能代表类，不能代表包)。util包和sql包下面都有Date类如果这种情况，还是要使用类的全名。


一个重载的构造器，其内部可以用this来调用另一个构造器。
... class ...{
gouzhaoqi(){}
gouzhaoqi(int a){...this();...}
}


方法的重写遵循两同两小一大（方法名相同、形参列表相同，两小是指子类返回值类型或抛出的异常类更小或相等）
super限定，可以调用父类被覆盖的方法，（也可以把子类对象转换成父类型再调用）
创建任何对象从该类所在的继承树最顶层的构造器开始执行


多态性：创建引用变量时，BaseClass p=new SubClass();//Java允许把一个子类对象直接赋值给一个父类引用变量，无需任何类型转换
当运行这个对象p时，其方法同子类，Field同父类，


if(objPri instanceof String){String str=(String)objPri;}强制类型转换之前的一个检测


组合
继承可能会破坏封装
继承：(is-a)
class A{...方法...}
class B extends A{}
class C extends B{}
组合：(has-a)
class A{...A方法...}
class B{
A a;
B(A a){...this.a=a;...}//在构造函数里进行传入
B方法(){a.A方法();}    //B方法调用了A方法
}
class C{
B b;
C(B b){...this.b=b;...}
C方法(){b.B方法();}
}


初始化块在构造器执行之前执行（new之前），一个类中静态初始化块最先执行，其次是普通初始化块，最后是构造函数（new时）


基本类型转换为包装类
boolean bl=true;
Boolean Bl=new Boolean(bl);//包装成包装类
包装类转化为基本类型
boolean bb=Bl.booleanValue();
另一种方法，
基本类型转换为包装类
Integer in=5;//Integer in=String.valueof(i);
Boolean bo=true;//Boolean bo=String.valueof(b);
包装类转化为基本类型
int i=Integer.parseInt(in);
bool b=Boolean.parseBool(bo);
自动装箱时有缓存机制
所有包装类都有compare方法，包装类都是不可变类


Object类的toString方法返回的是“类名+@+hashCode”值


==是指向同一个对象
equals是值相等即可


判断一个对象p是否是某个类的实例时，使用if(p.getClass()==类名.class)...来判断


有些类只能创建一个实例，单例类，构造器用private修饰，再提供一个public static方法调用构造器，还必须缓存已经创建的对象
class Singleton
{
private static Singleton instance;
private Singleton(){}
public static Singleton getInstance(){
  if(instance==null){instance=new Singleton();}
return instance;
} 


}
public class Test
{
public static void main(String[] args)
{
Singleton s1=Singleton.getInstance();
Singleton s2=Singleton.getInstance();//使用这种方法进行实例化
System.out.println(s1==s2); //输出true
}
}


用static final修饰的成员变量必须在初始化块或声明这个Field时指定初始值
用final修饰的成员变量必须在初始化块或声明这个Field或构造器时指定初始值
用final修饰基本类型变量时，无法再次将其赋值。但是用final修饰引用型变量时，会一直引用这个对象，但是对象可以发生改变
final修饰的变量若是满足定义时指定初值，初值可以在编译时确定下来，final变量其实就起到了类似宏的作用，变量本身其实不存在，存在的是常量
final类不可有子类


不可变类
使用final和private来修饰Field
提供带参数的构造器来传入参数来初始化Field
仅为Field提供getter方法，没有setter方法
可能要重写Object类的hashCode和equals方法
public class Address
{
private final String name;
private static int MAX=10;
private static Address[] cache=new Address[MAX];//存放缓存
private static int pos=0；

public Address(String name)
{
this.name=name;
}

public String getName(){return this.name;}

public static Address valueof(String name) //这个valueof函数和包装类中的valueOf类似
{
for(int i=0;i<MAX;i++){//遍历，看此对象是否在缓存中
if(cache[i]!=null&&cache[i].getName().equals(name))
return cache[i];
}
//没有则新建
if(pos==MAX){//如果缓存满了，从数组开头循环
cache[0]=new Address(name);
pos=1;
}
else
{
cache[pos++]=new Address(name);
}
return cache[pos-1];
}




//equals方法的重写
public boolean  equals(Object obj)
{
if(this==obj){return true}
if(obj!=null&&obj.getClass()==Address.class)
{
Address ad=(Address)obj;
return name.equals(ad.getName());
}
return false;
}


public int hashCode()
{return name.hashCode();}
}
在使用的时候不是一定new来生成对象
...
Address c1=Address.valueof("hello");
Address c2=Address.valueof("hello");
//通过这个方式没有新建重复的字符串
System.out.println(c1==c2);//输出true
...


有抽象方法的类是抽象类，不可实现
起到模板作用，父类（抽象）提供多个子类的通用方法，留下一两个抽象方法让子类实现


更彻底的抽象是接口
使用interface关键字，其中的方法只能是抽象方法
接口支持多继承，接口与其说是接口，不如说是子类必须实现的规范。
接口中不允许定义非抽象的、静态的方法，不含构造器和初始化块