java里方法的参数传递方式只有一种：值传递
例如：
void swap(int a,int b)
{
 tmp = a;
 a = b;
 b = tmp;
}
并不能交换a,b的值

void swap(DataWrap dw)
{
 tmp = dw.a;
 dw.a = dw.b
 dw.b = tmp;
}
可以交换，因为DataWrap是引用类型，所以swap复制了在栈区的dw变量，而不是堆内存中的对象，该dw副本也是指向堆内存中的对象，
因此，swap方法交换了堆内存中的a，b属性

void swap(int [] a)
{
 tmp = a[0];
 a[0] = a[1]
 a[1] = tmp;
}
可以交换，理由同上

形参可变的方法：在最后一个形参类型后面加三点...，其使用效果与使用数组类似，只不过它可以不用创建一个数组，调用更加简洁。但是，一个方法中只能有一个长度可变的形参，并且只能处于形参列表的最后。（大部分时间内不推荐使用，因为意义不大，还降低可读性）
例如：
public class Varargs
{
 public static void test(int a,String... books)
 {
  //books将被当做数组处理
  for(String tmp : books)
  {
   System.out.println(tmp);
  }
  System.out.println(a);
 }
 public static void main(String[] args)
 {
  test(5,"books1","books2","books3");
 }
}

成员变量无需显式初始化，只要定义了类属性或实例属性，系统会在这个类的准备阶段或创建这个类的实例时进行默认初始化。
而局部变量除了形参外，都需要显式初始化。否则，不可访问。

如下三种情况需要使用成员变量
1.如果需要定义的变量是用于描述某个类或者某个实例的固有信息。如人的身高、体重。
2.如果在某个类中，需要以一个变量来保存该类或者实例运行时的状态信息。
3.如果某个信息需要在某个类的多个方法之间进行共享。

访问控制级别表
  private    default   protected   public
同一个类中 yes    yes       yes         yes
同一个包中 no    yes       yes         yes
子类中  no    no      yes  yes
全局范围内 no    no      no   yes

如果一个Java源文件里定义所有类都没有用public修饰，则这个Java源文件的文件名可以是一切合法的文件名。但如果一个Java源文件定义了一个public修饰的类，则这个源文件的文件名必须与public的类名相同。

控制符使用基本原则
1. 类中的绝大部分属性应该用private修饰，除了一些static修饰的，类似全局变量的属性。一些用于辅助该类其他方法的工具方法，也应该用private修饰。
2.如果某个类主要用作其他类的父类，该类包含的大部分方法仅希望被子类重写而不希望被外界调用，则应该用protected修饰这些方法。
3.构造器和顶级类使用public修饰。

import语句中的（*）只能代表类，不能代表包
例如import java.util.*;仅代表java.util中的类而不包括java.util子包中的类。
如果要使用到java.util.zip包中的类则要使用import java.util.zip.*;语句。

在某些情况下，我们只能在源文件中使用类全名，而不能用import语句，例如我们需使用java.util.*中的Date类，又要使用java.sql.*中的Date类，因为两者都匹配，这时系统将无法分辨。

import除了可以导入类之外，还能导入静态方法
如：
import static java.lang.System.*;
import static java.lang.Math.*;
public class TestStaticImport
{
 public static void main(String[] args)
 {
  out.println(PI);
 }
}

一个构造器中直接使用另一个构造器的例子:
public class Apple
{
 public String name;
 public String color;
 public double weight;
 public Apple(String name,String color)
 {
  this.name = name;
  this.color = color;
 }
 public Apple(String name,String color,double weight)
 {
  this(name,color);
  this.weight = weight
 }
}

子类不能继承父类的构造器，需要通过super语句调用。

子类中包含与父类同名方法的现象被称为方法重写，也被称为方法覆盖（Override）；方法的重写要遵循“两同俩小一大”原则，即方法名相同，方法列表相同，子类方法返回值类型比父类更小或相等，子类抛出的异常比父类更小或相等。子类的访问权限比父类更大或相等。而且，他们要不都是类方法，要不都是实例方法，不能一个是类方法，一个是实例方法。子类要访问父类被覆盖的方法需需要使用super（覆盖的是实例方法）或者父类名（覆盖的是类方法）作为调用者来调用。

子类无法调用、继承、重写父类的private方法，如果子类中有与父类相同类名、返回值的private方法依然不是重写，只是子类中的一个新的方法。

系统查找某变量的顺序为：
1、查找该方法中是否有名为xxx的局部变量。
2、查找当前类中是否有包含名为xxx的属性。
3、查找xxx的直接父类中是否包含名为xxx的属性，依次上溯xxx的父类，直到java.lang.Object类，如果最终找不到名为xxx的属性，则出现编译错误。

无论我们是否使用super调用来执行父类构造器初始化代码，子类构造器都会调用父类构造器一次，因为系统会在执行子类构造器之前，隐式地调用父类无参构造器。

例如：
class Creature
{
 public Creature()
 {
  System.out.println("Creature无参构造器");
 }
}
class Animal extends Creature
{
 public Animal(String name)
 {
  System.out.println("Animal带一个参数的构造器，该动物为"+name);
 }
 public Animal(String name,int age)
 {
  this(name);
  System.out.println("Amimal带俩个参数的构造器，该动物的年龄为"+age);
 }
}
public class Wolf extends Animal
{
 public Wolf()
 {
  super("土狼",3);
  System.out.println("Wolf的无参构造器");
 }
 public static void main(String[] args)
 {
  new Wolf();
 }
}

将输出：
Creature无参构造器
Animal带一个参数的构造器，该动物为土狼
Amimal带俩个参数的构造器，该动物的年龄为3
Wolf的无参构造器

java引用变量有两个类型：一个是编译时的类型，一个是运行时的类型，编译时是类型由声明该变量时使用的类型决定，运行时的类型由实际赋给该变量的对象决定。如果运行时类型与编译时类型不一致，就会出现所谓的多态（Polymorphism）。

与方法不同，对象的属性则不具备多态性

把一个父类实例强制转换为子类实例，只有这个对象实际上确实是子类的实例才行。

在进行强制转换之前，用instanceof运算符来判断是否可以转换成功，使代码更加健壮，但是，前提是要转换的类型必须是该实例声明类型的子类才可以编译成功。

instancenof运算符使用实例：
public static void main(String[] args)
{
 Object hello ="hello";
 //String是Object的子类，返回true
 System.out.println(hello instanceof Object);
 //返回true
 System.out.println(hello instanceof String);
 //Math是Object的子类，但是，hello不是其实例，所以返回false
 System.out.println(hello instanceof Math);
 //String实现了Comparable接口，所以返回true
 System.out.println(hello instanceof Comparable);

 String a = "hello";
 //Math不是String的子类，所以无法编译
 System.out.println(a instanceof Math);
}

设计父类遵循的规则
1.尽量隐藏父类的内部数据。尽量吧父类的所有属性都设置成private访问类型，不让子类直接访问父类的属性。
2.不要让子类可以随意访问、修改父类的方法。父类中那些仅为工具的方法，应该使用private访问控制修饰符，让子类无法访问；如果父类中的方法需要被外部调用，必须以public修饰，但是又不希望被子类重写，可以使用final修饰符；如果希望父类的某个方法被子类重写，但不希望被其他类访问，可以使用protected来修饰。
3.不用在父类构造器中调用被子类重写的方法（会导致空指针异常）。

需要使用继承的条件
1.子类需要额外增加属性，而不是仅仅是属性值的改变。
2.子类需要增加自己独有的行为方式。

总结1