1 定义类，成员变量和方法

类和对象

定义类

java的类名由一个或者多个有意义的单词组合而成，每个单词的首字母大写，其他的全部消协，并且单词之间没有分隔符。

成员变量：用于定义该类或者实例的所包含的状态数据。

方法：用于定义该类或者实例所包含的功能实现和行为特征。

构造器：用于构造该类的实例。

定义成员变量的语法格式：

［修饰符］ 类型 成员变量名；

1，修饰符可以没有，也可以是public ,protected,private,static,final.前三个最多出现一个，可以与static final组合起来修饰成员变量

2，类型：任何类型，

3，成员变量名，第一个单词的首字母小写，其他的大写，用英文名词

4，默认值：定义成员变量可以指定一个可选的默认值。

定义方法的语法格式

［修饰符］返回值类型 方法名(形参列表)

｛

／／由0条或者多条可执行的语句构成的方法体

｝

1，修饰符：可以省略，public protected private static final abstract 前三个可以出现一个，final和abstract 只能出现其中之一，他们与static组合起来修饰方法

2，返回值类型：任何类型。如果生命了返回值类型，必须有有效的return语句，否则用void.

3，方法名 ，基本和成员变量的一样，最好用英文动词。

4，形参列表：0组到多组的“参数类型 形参名，参数类型 形参名，，，”

static关键字

static修饰的成员表示他是属于类的，类变量类方法。也叫静态。静态成员不能直接访问非静态成员。

static真正的作用是用来区分成员变量，方法，内部类，初始化块属于类本身还是属于实例。

定义构造器语法格式

［修饰符］ 构造器名 (形参列表)

｛

｝

1，修饰符可以是省略，public protected private其中之一

2，构造器名必须与类名相同

3，与方法的相同

java类的大致作用

定义变量

创建对象

调用类的类方法，或者访问类的类变量

创建并使用对象

对象的产生和使用

Person p=new Person();

p.say("你真棒")；

p.name(“李刚”);／／直接给成员变量赋值

对象和引用

堆里面的对象可以有多个引用。

Person p1=p;

这时p1和p指向同一个对象。

如果希望通知垃圾回收机制回收某个对象，把引用变量赋值为null

this

this关键字总是指向调用该方法的对象，谁调用它，他就指向谁，就可以获取成员变量和方法。

public class Dog {

public void jump()

{

System.out.println("正在执行jump方法");

}

public void run()

{

//如果想在这个方法里面调用另一个方法

//如果没有this，则必须再创建一个对象

//有了this，就不需要创建了，因为this就是指向调用该方法的对象

this.jump();

jump();

}

static修饰的方法，是用类来直接调用的，因此不需要再创建一个对象，因此也就不使用this，因此static对象不能访问非静态成员

public class StaticAccessNonStatic {

public void info()

{

System.out.println("简单的方法");

}

public static void main(String[] args) {

// TODO Auto-generated method stub

new StaticAccessNonStatic().info();

}

}

大部分时候，普通方法访问其他方法，成员变量无需使用this，但是如果方法里面有局部变量和成员变量同名，但是又需要在方法里面访问，则必须适应this

this也可以用于构造器作为默认引用。代表构造器正在初始化的对象。

public class ThisInConstructor {

//定义一个名为foo的成员变量

public int foo;

public ThisInConstructor ()

{

// 在构造器中又定义了一个foo

//this代表正在初始化的对象，把他的foo成员变量设为6

int foo=0;

this.foo=6;

}

this还可以作为普通方法的返回值，表示返回调用该方法的对象

方法必须属于类或者对象

java里面的类不能独立存在，必须放在类里面

方法的所属性

2 java方法的参数传递机制

值传递

参数传递方式是一种值传递方式。也就是实参的副本保存在形参中。如果形参是基本类型，那么方法中对形参的修改不会改变实参；如果形参是引用类型，仍然是指传递，由于引用类型是指针，保存的是地址，所以方法中对形参的修改会改变实参的值，但是如果在方法中把形参的引用赋值为null，则实参不会改变。

class DataWrap

{

int a;

int b;

}

public class ReferenceTransferTest {

public static void swap(DataWrap dw)

{

int temp=dw.a;

dw.a=dw.b;

dw.b=temp;

System.out.println("在swap方法里面a是"+dw.a+"b是"+dw.b);

}

public static void main(String[] args) {

// TODO Auto-generated method stub

ReferenceTransferTest rf=new ReferenceTransferTest();

DataWrap dw=new DataWrap();

dw.a=9;

dw.b=4;

rf.swap(dw);

System.out.println("交换结束后a是"+dw.a+"b是"+dw.b);

}

}

参数个数可变的方法

在最后一个形参的类型后面加上"...", 表示形参可以接受多个参数。本质上就是一个数组类型的形参。传入的实参可以是多个参数，也可以是一个数组。

但是参数个数可变的形参必须处于形参列表的最后，且只能有一个。

如果形参是数组的话，传递的方式是

test(new String[]{"abs","cps"});

如果形参时参数可变的，传递方式除了上边的方式，还可以是

test("abs","cds");

public class Varargs {

//定义一个参数可变的方法

public static void test(int a,String ...books)

{

//books被当作数组处理

for(String tmp:books)

{

System.out.println(tmp);

}

}

public static void main(String[] args) {

// TODO Auto-generated method stub

test(4,"ans","csd");

}

}

3 递归方法

定义：一个方法体内调用自身。

只要一个方法的方法体实现中再次调用了自身方法，就是递归。递归必须向已知方向递归

public class Recursive {

public static int fn(int n)

{

if(n==1)

{

return 1;

}else if(n==2)

{

return 2;

}

else

{

//方法中调用自身

return 2*fn(n-1)+fn(n-2);

}

}

public static void main(String[] args) {

// TODO Auto-generated method stub

System.out.println(fn(10));

}

}

4 方法的重载

“两同一不同”

同一个类中方法名相同，参数列表不同。

注意被重载的方法里面包含了参数可变的形参。

public class OverloadVarargs {

public void test(String msg)

{

System.out.println("只有一个形参的test方法");

}

public void test(String ... books)

{

System.out.println("多个形参的test方法");

}

public static void main(String[] args) {

// TODO Auto-generated method stub

OverloadVarargs olV =new OverloadVarargs();

olV.test("aa");

olV.test("bb","cc","dd");

olV.test();

olV.test(new String[]{"aa"});

}

}

5 成员变量和局部变量

必须先给方法局部变量和代码块局部变量现实初始化，即指定初始值。否则不可以访问。

一个类不能有两个同名的成员变量，一个方法也不能有两个同名的方法局部变量。但是两个代码块里面的代码块局部变量可以同名。

如果先定义代码块局部变量，后定义方法局部变量。代码块和方法里面的局部变量也可以同名。

允许局部变量和成员变量同名。此时局部变量覆盖成员变量，如果想访问成员变量，要用this。

成员变量的初始化和内存中的运行机制

类变量和成员变量都在堆中保存。只是不再同一个地方。成员变量属于实例，类变量属于类。

局部变量的初始化和内存中的运行机制

局部变量保存在栈中，不需要垃圾回收，占的内存很小。直到被付初值才会被分配内存

变量的使用规则

成员变量的使用情形

某个类或者实例的固有信息。如果个个实例都是一样的，用类变量。如果不是一样的，用实例变量。

保存该类或者实例运行时候的状态信息。

多个方法都要用到。

6 实现良好的封装

理解封装

通过访问控制符把该隐藏的隐藏起来，该暴露的暴露出来。

使用访问控制符

private 类访问权限

default 包访问权限

protected 子类访问权限

public 公共访问权限

关于访问控制符的使用

绝大部分成员变量都用private,只有少部分用static,类似全局变量的成员变量用public。除此之外，辅助实现该类的其他方法的工具类也用private。

如果某个类主要做其他类的父类，则用protected.

构造器用public。大部分外部类用public。

7 使用package和import

package ,import,import static

同一个包下的类可以自由访问，但是子包里面的还是必须要写全名

import可以导入包下面的全部类，子包单独import

import static导入静态成员变量，方法

java 常用包

8 构造器的作用和构造器重载

8.1使用构造器执行初始化

在系统执行构造器的执行体之前，系统已经创建了一个对象，只是还不能被外部访问。

9 继承的特点和用法

9.1继承的特点

java是单继承，只能有一个直接父类，但是可以有多个间接父类。

子类是父类的扩展。子类不能获得父类的构造函数。

10 重写父类方法

如果子类对于继承下来的父类的方法不满意，可以重写这个方法。

‘两同两小一大原则’

“两同” 方法名相同，参数列表相同

“两小” 返回值类型要小，抛出的异常要小

“一大” 权限要大

重载和重写：是两个东西。重载是一个类的多个方法，由于形参列表不同所以不同；重写是子类又写了一个和父类对应的方法。

11 super关键字的用法

super用来限定该对象调用父类被覆盖的实例方法。不能够用于static修饰的方法中，因为static是作用于类的。

创建一个子类对象时，系统会给该类中定义的实例变量和父类继承来的实力变量分配内存，即使二者同名。

11.2调用父类构造器

用super可以显式调用父类构造器。必须出现在子类构造器执行体的第一行，因此不能和this同时出现。

当调用子类构造器初始化子类对象，父类构造器一定会在子类构造器之前执行。

12 继承和多态

12.1多态性

java引用变量有两个类型，一个是编译时候的类型，一个是运行时候的类型。编译时候的类型和声明的类型相同，运行时候的类型由实际赋给该变量的对象决定。称为多态。

相同类型的变量，调用同一个方法时呈现出多种不同的行为特征，这就是多态。

成员变量不具有多态性。

12.2 引用变量的强制类型转换

如果想让引用变量调用它运行时的类型的方法，则需要强制类型转换。只能是具有继承关系的两个类型之间。如果是两个没有任何关系的，无法通过编译。如果父类实例转化成子类实例，则这个对象在运行时候必须是子类实例才行，否则会有异常。用instanceof处理。

12.3 instanceof运算符

instanceof运算符前一个是引用变量，后一个是一个类型。用于判断前面的对象是不是后面的类，或者是不是他的子类，或者实现类的实例。如果是，返回true

前面操作数的编译时候的类型要么和后面的类型相同，要么和后面的有父子继承关系(不一定是子类，可以是父类)，否则编译有错误。

编译想通过的话，只要有继承关系就行。想返回true，前面的不能是后 面的父类。

13 继承和组合的关系

13.1 使用继承的注意点

尽量隐藏父类的内部数据

不要让子类可以随便访问更改父类的方法。辅助方法设置成private；

如果父类中的方法需要被外部类调用，但是又不想让子类重写这个方法，可以加final；

如果希望子类重写该方法，但是不希望其他类自由调用，用protected

父类的构造器里面不要有子类会修改的方法。否则容易出现空指针。

因为创建子类的对象的时候，一定会先调用父类的构造器，构造器里面调用的方法已经被子类覆盖，所以运行时用的方法是子类的方法。但是子类还没有创建，因此会有空指针的可能性。

什么时候从父类派生子类？

增加了新的属性

增加了新的方法

使用组合来实现复用

组合是一种“has”的关系，譬如人有胳膊，腿。

组合和继承的开销一样。

至于怎么用的，书里面写的太少了。没有看明白

先定义private的父类的成员变量，然后在子类的构造器的形参中加入这个成员变量。然后把父类里面所有的public再写一次。(父类子类并不是这样，只是我不知道怎么能够说清楚)

13 构造器和初始化块的作用及区别

13.1 使用初始化块

java类里面可以出现的第四种成员。修饰符只能是static。当创建java对象时，总是先调用该类里面定义的初始化模块，再调用构造函数。

13.2 初始化块和构造器

如果两个构造器里面有相同的代码初始化代码，且这些初始化代码无需接受参数，就可以把它们放在初始化块中定义。

13.3 静态初始化块

如果希望加载类时，对整个类进行某些初始化操作，使用static关键字来修饰初始化模块。叫做类初始化块。