Java面向对象基础

java语言是面向对象的

计算机语言的发展由面向机器向面向对象发展的，是越来越符合人的思维习惯的。

类和对象的关系

类是对象抽象出来的概念性的通用性的东西。

实例和对象的关系

(对象就是实例，实例就是对象)java最大的特点就是面向对象。

类和对象的区别和联系

1、类是抽象的，概念的，代表一类事物，比如人类，动物类..

2、对象是具体的，实际的，代表一个具体事物，比如人类的对象“张三”..

3、类是对象的模板，对象是类的一个具体实例

类--如何定义类

一个全面的类定义比较复杂，如下：

类--类的成员变量

成员变量是类的一个组成部分，一般是基本数据类型，也可是引用类型。

对象--如何创建对象

创建一个对象有两种方法

1、先声明再创建

  1、对象声明：类名 对象名

  2、对象创建：对象名=new 类名()

2、声明创建一起

   类名 对象名=new 类名()

对象--如何访问(使用)对象的成员变量

   对象名.变量名; //先这样理解，以后加下访问控制符此表达就不准确了。

***对象总是存在内存中的(具体应该在系统分配给JVM的堆区)

类--类的成员方法定义

成员方法也叫成员函数。

1、参数列表：表示成员方法的输入参数

2、返回数据类型：表示成员方法的输出

3、方法主体：表示实现某一功能的代码块

定义名字的规范写法：(PS:很多类型在之后的内容中会展示，这里做个总结)

除了上述驼峰法标准写法之外，还可以用下滑线法，如 my_class,my_cat

类的成员方法--声明

这句话的作用是声明该方法，声明的格式为：

访问修饰符 数据类型 方法名(参数列表);

在给Person类添加add方法的例子中，关键字return的功能是把表达式的值返回的值返回给主调方法。

类的成员方法(函数)--特别说明

1、方法的参数列表可以是多个

参数列表可以是多个，并且数据类型可以是任意的类型int float double char..

2、方法可以没有返回值

返回类型可以是任意的数据类型(int,float,double,char..)也可以没有返回值void表示没有返回值

类的构造方法介绍

构造方法是类的一种特殊的方法，它的主要作用是完成对新对象的初始化。它有几个特点：

1、方法名和类名相同

2、没有返回值

3、在创建一个类的新对象时，系统会自动的调用该类的构造方法完成对新对象的初始化。

特别说明：

一个类可以定义多个不同的构造方法。

类的默认构造方法

如果没有定义构造方法，系统会自动生成一个默认构造方法。当创建Person对象时Person per1=new Person();默认的构造方法就会被自动调用。

类的构造方法小结：

1、构造方法名和类名相同；

2、构造方法没有返回值；

3、主要作用是完成对新对象的初始化；

4、在创建新对象时，系统自动的调用该类的构造方法；

5、一个类可以有多个构造方法；

6、每个类都有一个默认的构造方法。

this是属于一个对象，不属于类的。java虚拟机会给每个对象分配this,代表当前对象。

注意事项：this不能在类定义的外部使用，只能在类定义的方法中使用。

类变量

类变量是该类的所有对象共享的变量，任何一个该类的对象去访问它时，取到的都是相同的值，同样任何一个该类的对象去修改它时，修改的也是同一个变量。

定义类变量：

例如Person类中的

访问类变量：

类名.类变量名  或者  对象名.类变量名

例如

或者

类方法

类方法是属于所有对象实例的，其形式如下：

注意：类方法中不能访问非静态变量(类变量)。

使用：类名.类方法名 或者 对象名.类方法名

*重点*static静态的方法可以访问static静态变量(类变量)，不能访问非静态变量，非静态方法可以访问非静态变量同时也可以访问static静态变量(类变量)。

类变量小结

1、当某一属性是所有对象所公有(共用)的情况用类变量

2、类变量与实例变量区别：

加上static称为类变量或静态变量，否则称为实例变量

类变量是与类相关的，公共的属性

实例变量属于每个对象个体的属性

类变量可以通过 [类名.类变量名]  直接访问

类方法小结

1、当某一方法只使用或不使用静态变量(类变量)的情况用类方法

类方法属于与类相关的，公共的方法

实例方法属于每个对象个体的方法

类方法可以通过 [类名.类方法名]  直接访问

抽象

把一类事物的共有的属性和行为提取出来，形成一个模型(模版)。这种研究问题的方法称为抽象。

封装

封装就是把抽象出来的数据和对数据的操作封装在一起，数据被保护在内部，程序的其它部分只有通过被授权的操作(成员方法)，才能对数据进行操作。

封装--访问控制修饰符

java提供四种访问控制修饰符号控制方法和变量的访问权限：

1、公开级别：用public修饰，对外公开

2、受保护级别：用protected修饰，对子类和同一个包中的类公开

3、默认级别：没有修饰符号，向同一个包的类公开

4、私有级别：用private修饰，只有类本身可以访问，不对外公开

包--必要性

包--三大作用

1、区分相同名字的类

2、当类很多时，可以很好的管理类

3、控制访问范围

包--导包命令

package com.自定义名字;

注意：导包命令一般放在文件开始处。

包--命名规范

小写字母  比如 com.test

包--常用的包

一个包下，包含很多的类，java中常用的包有：

  上表中的这些包，除了第一个包是自动导入外，其余的包都需要使用import语句导入，才可使用其包里面的类与接口。

 

包--如何引入包

语法：import 包;

比如import java.awt.*;

引入一个包的主要目的要使用该包下的类。

继承

继承--基础知识

继承可以解决代码复用，让编程更加靠近人类思维。当多个类存在相同的属性(变量)和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends语句来声明继承父类：

语法：class 子类 extends 父类

这样，子类就会自动拥有父类定义的某些属性和方法。

继承--深入讨论

1、

2、结论

从表可以看出，父类的public修饰符的属性和方法；protected修饰符的属性和方法；默认修饰符属性和方法被子类继承了，父类的private修饰符的属性和方法不能被子类继承。

继承--注意事项

1、子类最多只能继承一个父类(指直接继承)

2、java所有类都是Object类的子类 (所有的子类都可以逐级继承，例:爷->父->子->孙)

方法重载(overload)和方法覆盖(override)

在实现多态前，必须先弄明白方法重载(overload)和方法覆盖(override)。

方法重载(overload)

方法重载就是类的同一种功能的多种实现方式，到底采用哪种方式，取决于调用者给出的参数。

1、方法名相同

2、方法的参数类型，个数，顺序至少有一项不同

3、方法返回类型可以不同(只是返回类型不一样，不能构成重载)

4、方法的修饰符可以不同(只是控制访问修饰符不同，不能构成重载)

方法覆盖(override)

方法覆盖就是子类有一个方法，和父类的某个方法的名称、返回类型、参数一样，这就是子类的这个方法覆盖了父类的那个方法。

方法覆盖有如下条件：

1、子类的方法的返回类型，参数，方法名称，要和父类的返回类型，参数，方法名称完全一样，否则编译出错。

2、子类方法不能缩小父类方法的访问权限。

多态--概念

多态是指一个引用(类型)在不同情况下的多种状态。也可以理解成：多态是指通过指向父类的指针，来调用在不同子类中实现的方法。

实现多态有两种方式：1、继承；2、接口

多态--注意事项：

1、java允许父类的引用变量引用它的子类的实例(对象)

2、如果需要访问子类中父类没有的数据，需要强制转换为子类

多态--补充

继承是多态得以实现的基础。从字面上理解，多态就是一种对象引用(类型)表现出多种状态。将一个方法调用同这个方法所属的主体(也就是对象或类)关联起来叫做绑定，分前期绑定和后期绑定两种。下面解释一下它们的定义：

1、前期绑定：在程序运行之前进行绑定，由编译器和连接程序实现，又叫做静态绑定。比如static方法和final方法，注意，这里也包括private方法，因为它是隐式final的。

2、后期绑定：在运行时根据对象的类型进行绑定，由方法调用机制实现，因此又叫做动态绑定，或者运行时绑定。除了前期绑定外的所有方法都属于后期绑定。

多态就是在后期绑定这种机制上实现的。多态给我们带来的好处是消除了类之间的偶合关系，使程序更容易扩展。

当类的一些方法不能确定时，可以用abstract关键字来修饰该方法[抽象方法]，用abstract来修饰该类[抽象类]。

抽象类--深入讨论

1、用abstract关键字来修饰一个类时，这个类就是抽象类。

2、用abstract关键字来修饰一个方法时，这个方法就是抽象方法。

3、abstract抽象类中的abstract抽象方法是不允许在抽象类中实现的，一旦实现就不是抽象方法和抽象类了。abstract抽象方法只能在子类中实现。

4、抽象类中可以拥有实现方法。

抽象类--注意事项

1、抽象类不能被实例化

2、抽象类不一定要包含abstract方法。也就是说，抽象类可以没有abstract抽象方法。

3、一旦类包含了abstract抽象方法，则这个类必须声明为abstract抽象类。

4、抽象方法不能有主体。

正确的抽象方法例：abstract void abc();

错误的抽象方法例：abstract void abc(){} 

接口就是给出一些没有内容的方法，封装到一起，到某个类要使用的时候，在根据具体情况把这些方法写出来。

接口建立语法：

接口实现语法：

小结：

接口是更加抽象的抽象的类，抽象类里的方法可以有方法体，接口里的所有方法都没有方法体。接口体现了程序设计的多态和高内聚低偶合的设计思想。

接口--注意事项

1、接口不能被实例化

2、接口中所有的方法都不能有主体。错误语法例：void aaa(){}，接口可以看作更加抽象的抽象类。

3、一个类可以实现多个接口

4、接口中可以有变量[但变量不能用private和protected修饰]

   a、接口中的变量，本质上都是static的而且是final类型的，不管你加不加static修饰

   b、在java开发中，经常把常用的变量，定义在接口中，作为全局变量使用

访问形式：接口名.变量名

5、一个接口不能继承其它的类，但是可以继承别的接口，而且可以多继承

6、当一个类实现了一个接口，要求该类把这个接口的所有方法全部实现

实现接口VS继承类

java的继承是单继承，也就是一个类最多只能有一个父类，这种单继承的机制可保证类的纯洁性，比C++中的多继承机制简洁。但是不可否认，对子类功能的扩展有一定影响。

所以：

1、实现接口可以看作是对继承的一种补充。(继承是层级式的，不太灵活。修改某个类就会打破继承的平衡，而接口就没有这样的麻烦，因为它只针对实现接口的类才起作用)

2、实现接口可在不打破继承关系的前提下，对某个类功能扩展，非常灵活。

final基本概念

1、final中文意思：最后的，最终的。

2、final可以修饰变量或者方法。

3、被final修饰的变量其数据就不能改变了，就成为了常量(const)。

在某些情况下，可能有以下需求：

1、当不希望父类的某个方法被子类覆盖(override)时，可以用final关键字修饰。

2、当不希望类的某个变量的值被修改，可以用final修饰。如果一个变量是final，则必须赋初值，否则编译出错。

3、当不希望类被继承时，可以用final修饰。

final--注意事项

1、final修饰的变量又叫常量，一般用XX_XX_XX(大写)来命名。(带下划线)

2、final修饰的变量在定义时，必须赋值，并且以后不能再赋值。

final--什么时候用

1、类的某个方法不允许修改。

2、类不想被其它的类继承。

3、某些变量值是固定不变的，比如圆周率3.1415926

结论：

1、静态代码块只会在类加载进内存时，被执行一次。

2、代码块会在每次创建对象被执行一次。

3、代码块的访问顺序是从上至下，依次访问。

----------参考《韩顺平.循序渐进学.java.从入门到精通》

----------参考《JDK_API_1_6_zh_CN》