3.面向对象的基础知识

1、类、对象的概念(面向对象的特征：封装、继承、多态）

类就是同一类型对象的抽象，对象是类的实例.

类的成员变量和方法。

2、类的定义

修饰符 class 类名称 {

    修饰符 数据类型 成员变量；

    修饰符 返回类型 方法名(参数1，参数2，...) {

     程序语句；

     return 表达式；

     }

}

public class Person {

    String name;

    int age;

    public void talk() {

     System.out.println("我是："+name+"，今年"+age+"岁");

    }

}

3、对象的创建

类名 对象名 = new 类名();

Person p = new Person();

匿名对象:如new Person().talk();

4、访问对象的成员变量或方法

对象.成员变量

对象.方法()

5、构造方法

构造所完成的工作是为新创建的对象赋初值.

1)与类名相同的方法名称;

2)没有返回值;

3)调用时机在对象创建时自动调用；系统默认构造了一个无参的构造方法;

4)构造方法也可以重载，一旦重载了构造方法，系统不再构造无参的构造方法；

继承中的构造方法

子类的构造过程必须调用基类的构造方法；

子类可以在自己的构造方法中使用super(参数)调用父类的构造方法；

如果子类的构造方法中没有显式调用父类的构造方法，则系统默认调用父类的无参构造方法；

如果子类构造方法没有显式调用父类的构造方法，而父类没有无参构造方法，则编译出错；

6、类的封装

1)把对象的属性和行为看成一个密不可分的整体，将两者封装在一个不可分割的独立单位（对象）中；

2)信息隐蔽;

为了保护成员变量的私有性，常常将成员变量设置为private,然后对成员变量增加setXXX，getXXX方法

7、类的多态

方法的重载(overload):在一个类中，允许方法使用同一个名字，但方法的参数不同，(类型不一样，或者个数不一样）完成的功能也不同。

方法的重写(overwrite)：子类与父类允许有相同的变量名称，但数据类型不同，允许有相同的方法名称，但完成的功能不同。

8、对象的比较

有两种方法来进行对象的比较；"=="和"equals()"方法

==运算符用于比较两个对象的内存地址是否相等；

equals方法比较两个对象内容是否一致；

String str1 = "java";

String str2 = new String("java");

string str3 ="java";

System.out.println("str1 == str2 ? -->"+ (str1 == str2);false

System.out.println("str1 == str3 ? -->" + (str1 == str3);true

System.out.println("str3 == str2 ? -->" + (str3 == str2);false

字符串常量是在DataSegment存放"java",然后str1和str3都指向该地址；

str2是指向了堆中新建的字符串

9、this和super

this表示该对象本身的引用

super表示父类的引用

10、static

如果用static修饰符限定变量，则该变量为静态变量，存放在datasegment中。

如果成员变量限定为static，则成为类的公共成员了。该成员属于所有对象共享的。

该成员变量可以通过类名直接访问；静态方法不能访问非static成员变量；

11、对象数组

1)声明类类型的数组变量，并用new分配存储空间给数组;

2)用new产生新的对象，并赋值给数组对象；

Person [] p = new Person[3];

p[0] = new Person();

p[1] = new Person();

p[2] = new Person();

12、package和import语句

为了解决类名的冲突，采用package机制；

1、package语句作为源文件的第一条语句；在源代码的第一行,约定俗成，包名一般把公司名倒过来；

package com.oushine.shui;

编译出来的类必须位于正确的目录下；com\oushine\shui；同时删除该类的java源文件；

2、如果想要引用该包中的类，需要使用import语句，将该包引入；如果要引用的类和该类位于同一个包下，不需要引入包；

import com.oushine.shui.*;

import com.oushine.*;

3、为class文件打包；jar -cvf test.jar *.*

13、常用包

java.lang：包含java语言的核心类；String,Math,Integer,System和Thread;

java.awt；(abstract windows toolkits)；

java.applet；包含运行applet所需的类；

java.net；包含网络相关的类；

java.io；包含提供输入输出功能的类；

java.util；包含一些实用工具类，如日期等；

14、访问控制

private:类内部可以访问

default:同一个包下可以访问(默认情况，如果什么都没写即为default权限)

protected:子类可以访问

public:任何情况可以访问

对于class只有public和default权限

15、继承（单继承）

class Parent{}

class Child extends Parent{}

java只能支持单继承，不支持多继承；

通过继承，子类自动拥有了父类的所有成员变量和方法；

在对象的实例化时，会先调用父类的构造方法，然后调用子类的构造方法；实际上在子类的构造方法第一行语句默认调用了super();

16、方法的重写（overwrite)

在子类中可以对从父类继承的方法进行重写；

重写方法必须和被重写的方法具有相同的名称、参数列表、返回类型；

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

17、抽象类

抽象类有点类似于模板，不能直接从抽象类创建对象，只能通过抽象类派生出新的类，由它来创建对象；

1)抽象类和抽象方法必须用abstract修饰；

2)抽象类不能实例化，也就是不能用new来产生对象； 

3)抽象方法只需声明，不需实现；

4)含有抽象方法的类必须声明为抽象类，抽象类的子类必须覆写(override)了所有抽象方法后，才能实例化，否则这个子类还是抽象类；

在抽象类中，也可以有构造方法，但这些构造方法只能在子类中通过super()来调用;

overload （重载）  

    1.使用的地方：同一类里。（其实是同一类里同一名称的方法不同版本的一种叫法）

    2. 要重载的方法和被重载的方法要求：参数列表类型不同或个数不同或二者都不同) 

overwrite （重写）  

    重写是从父类继承的方法，一旦子类重写了方法，就像父类里不存在这些方法一样。 

override （覆写）

    override的方法必须父类的(直接父类或间接父类(就是向上n层的父类))虚方法或抽象方法其中抽象方法是必须覆写的。

18、Object类

Object类是所有类的父类，一个类没有使用extends明确标识继承了另外一个类，则这个类默认继承了Object;

Object类的toString()方法；此方法是在打印对象时被调用的；

Person p = new Person();

System.out.println(p);

19、final关键字

1)final标记的类不能被继承；

2)final标记的方法不能被子类重写；

3)final标记的变量（局部变量或成员变量）即为常量，只能赋值一次；

20、接口(interface)

接口是java中用来实现多继承的一种机制；每一个由接口实现的类必须在类中复写接口中的抽象方法，且可以自由使用接口中的常量；

接口与抽象类非常相似，也具有成员变量和抽象方法，但和抽象类又不同：

1)接口里的数据成员必须初始化，且数据成员均为常量；

2)接口里的的方法必须全部声明为abstract，也就是说接口不能象抽象类一样保有一般的方法，而必须全部是抽象方法；

接口的定义

interface 接口名称

{public static final 数据类型 成员变量 = 常量；(默认，也只能）

 public abstract 返回值的数据类型 方法名(参数...);

//抽象方法，注意在抽象方法里，没有定义方法主体；

}

由于成员变量必须定义为public static final，方法必须为public abstract，所以final和abstract关键字可以省略

由于接口只有abstract方法，也没有办法象一般类一样用来创建对象，利用接口打造新的类的过程，称为接口的实现(implementation)

接口的实现

class 类名称 implements 接口A,接口B 

{

}

接口可以通过extends来实现接口的扩展（继承），与类的继承不同的是，接口可以继承多个接口，同时继承了多个接口的抽象方法和常量；

interface 接口名称 extends 父接口1，父接口2...

{

}

21、多态性

子类实例化对象可以转换为父类实例化对象

Person p = new Student();

向上转型(upcasting)：父类对象通过子类对象实例化，就是向上转型，向上转型不需要进行强制类型转换；

向下转型(downcasting)：子类对象可以通过父类对象实例化，这时必须要进行强制类型转换；

一个父类的引用类型变量可以指向子类的对象；

动态绑定：指在执行期间(非编译期间）判断所引用对象的实际类型， 根据其实际类型调用相应方法；

调用方法的时候根据实际类型来调用的；

多态存在的必要条件：

1）要有继承；

2）要有重写；

3）父类引用指向子类对象；

22、instanceof

判断一个类是否实现了某个接口，也可以判断一个对象是否属于某个类

对象 instanceof 类（接口）返回true,false;

23、内部类

 public class T {

//属性；

//方法；

class TT {

}

}

TT叫内部类，T就叫包装类，编译后会生成T.class和T$TT.class