面向对象程序设计的基本概念
对象
对象具有两方面的含义:
在现实生活中: 是客观世界中的一个实体在计算机世界中： 是一个可标识的存储区域
类(class)
类：具有共同属性和行为的对象集合属性：变量(字段 field)行为：函数(方法 method)类与对象的关系
类是对象的抽象(模板)对象是类的实例 注：类和对象有时候都统称为“对象”，为了明确起见，后者称为“对象实例”。
# Person类
class Person{
int age
;
String name
;
void sayHello(){...}
}
# 对象实例化
Person person
= new Person();
面向对象的三大特征
封装性继承性多态性
封装
1.定义：隐藏对象的属性和实现细节，仅对外公开接口,控制在程序中属性的读和修改的访问级别。2.封装的目的是：增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，一特定的访问权限来使用类的成员。3.封装的基本要求是:把所有的属性私有化，对每个属性提供getter和setter方法，如果有一个带参的构造函数的话，那一定要写一个不带参的构造函数。在开发的时候经常要对已经编写的类进行测试，所以在有的时候还有重写toString方法，但这不是必须的。模块化：将属性和行为封装在类中，程序定义很多类。信息隐蔽：将类的细节部分隐藏起来，用户只通过受保护的接口访问某个类。
class Person{
private int age
;
public int getAge(){
return age
;
}
public void setAge(int a
){
age
=a
;
}
String name
;
void sayHello(){...}
}
继承(inheritance)
继承性父类和子类之间共享数据和方法继承的好处更好的进行抽象与分类增强代码的重用性提高可维护性
父类
class Person{
int age
;
String name
;
void sayHello(){...}
}
子类
class Student extends Person{
String school
;
double score
;
void meetTeacher(){...}
}
多态
不同的对象收到同一个消息(调用方法)可产生完全不同的效果实现的细节则由接受对象自行决定例 foo(Person p ){ p.sayHello(); }foo( new Student() );foo( new Teacher() );
类的使用方法
类声明
类在使用前，必须先声明，然后才可以声明变量，创建对象。类的声明语法如下：
[标识符
] class 类名
{
}
[修饰符
]class 类名
[extends 父类
] [implements 接口名
]
{
属性
(成员变量
)->基本数据类型
,对象
操作
(成员方法
)->函数
}
修饰符
首先每一个类都会有访问权限，指明这些类可以被哪些类访问。JAVA通过在类声明时，指定修饰符来约定访问权限。在java中有4种修饰符，分别是public、private、protected和缺省值。对于它们所指代的访问劝限如下：
public：修饰顶层类和成员类，表明该类是一个公共类，可被任何类访问。（注意哦，同一个java源文件只能有一个公共类）
private：修饰成员类，表明是一个私有类，只能被顶层类访问。
protected：修饰成员类，表明该类是一个受保护的类，只能被自身类、自身类的子类以及与其自身类同胞的类访问(总结来说就是可以被同包的类访问)。
缺省值：定义类时，可以忽略掉修饰符，代表该类只能被同胞的类访问。
static
用于修饰成员类，代表该类是一个静态类，静态类是其顶层类的固有对象，不用创建实例，且可以直接引用。
final
指明类为最终类，不会有子类，所以不能被继承。
abstract
指明类为抽象类，抽象类没有完全实现，所以不能被实例化，也不能直接引用。（注意abstract和final不能修饰同一个类，原因从意义上就能看出）
strictfp
用strictfp关键字表示精确浮点数，修饰的类中所有的运算都是严格按照浮点运算规范IEEE-754进行，保证精确性。
成员变量与常量
成员变量(全局变量)：在类体中所定义的变量为成员变量，成员变量在整个类中都有效。类的成员变量又分为两种：静态变量和实例变量 成员变量和局部变量的有效范围：
①成员变量(在类体中所定义的变量为成员变量)：在整个类中都有效②局部变量(再类的方法内声明变量，包括方法的参数都属于局部变量)：只在当前定义的方法内有效,不能用于类的其他方法中。局部变量的生命周期取决于方法，当方法被调用时，Java虚拟机为方法中的局部变量分配内存空间，当该方法调用结束后，则会释放方法中局部变量占用的内存空间，局部变量也将被销毁。③局部变量可与成员变量的名字相同，此时成员变量将被隐藏，即这个成员变量在此方法中暂时失效。 常量
①常量的定义：在程序运行过程一直不会改变的量称为常量，通常也成为"final变量"。常量在整个程序中只能被赋值一次。在为所有的对象共享值时，常量是非常有用的。声明常量的标准语法为：final 数据类型 变量名[=值]②常量名通常使用大写字母，但这不是必须。很多Java程序员使用大写字母表示常量，是为了清楚的表明正在使用常量。③当定义的final变量为成员变量时，必须在定义时就设定它的初始值，否则将会提示编译错误。
public class Student {
private int Id
;
private String name
;
public int age
;
private static String height
= "个子很高";
public static final String mood
= "开心";
public void study() {
String study
= "learning";
}
public int getId() {
return Id
;
}
public void setId(int id
) {
Id
= id
;
}
public String
getName() {
return name
;
}
public void setName(String name
) {
this.name
= name
;
}
public int getAge() {
return age
;
}
public void setAge(int age
) {
this.age
= age
;
}
}
方法的声明与实现
方法就是一段可重复调用的代码段，例如，有某段长度约100 行的代码，要在多个地方使用此段代码，如果在各个地方都重复编写此部分代码，则肯定会比较麻烦，而且此部分代码如果进行修改也比较困难，所以此时可以将此部分代码定义成一个方法，以供程序反复调用。方法与函数的关系：方法和函数是相同的概念，只是在面向对象的语言中常称为方法（method），在面向过程的语言中常称为函数（function）。方法的声明：
public static 返回值类型 方法名称 （
[参数类型 变量
...]）
方法体代码；
[return 返回值
]；
# 方法声明的一般形式：
【可访问性修饰符】【
abstract】【
static】【
final】【
native】【synchronize】返回类型 方法名（参数表）【
throws 异常类名表】
{
}
方法的修饰符方法的修饰符分为访问控制修饰符和非访问控制修饰符
【访问性修饰符】:与成员变量的访问修饰符的作用和方法一样。 常见的非访问控制修饰符
【abstract】:修饰词abstract修饰的为抽象方法，仅含有方法的声明部分，而没有方法体和具体的操作实现部分的方法。那么为什么不定义方法的实现呢？链接【static】：static修饰的方法是属于整个类的方法，简称类方法。当第一次调用含有类方法的类时，系统只为该类的类方法创建一个版本。这个版本被该类和所有实例所共享。与之对应，无static修饰的方法为的实例方法。注意：类方法不能直接访问实例变量；实例方法可以对当前对象的实例变量进行操作，而且可以访问类变量。【final】：最终方法。最终方法是不能被当前类的子类重新定义的方法（注：所有已被private修饰符限定为私有的方法以及所有包含在final类中的方法，都被默认为是final的）。【native】：本地方法。一般用来声明用其他语言（C、C++、FORTRAN和汇编等）书写方法体的特殊方法。【synchronize】:若synchronized修饰的方法是一个类方法，那么在这个方法被调用执行前，将把系统类Class中对应当前类的对象加锁；案例 如果不需要传递参数到方法中，只要将括号写出，不必填入任何内容。此外，如果方法没有返回值，则在返回值类型处要明确写出void,此时在方法中的return语句可以省略。方法执行完后无论是否存在返回值都将返回到方法的调用处并向下继续执行。
例
:定义一个方法，在主方法中进行调用
public class MethodDemo01{
public static void main(String
[] args
){
printInfo();
printInfo();
printInfo();
System
.out
.println("Hello World!");
}
public static void printInfo(){
char c
[] = {'H', 'e', '1','l', 'o'};
for(int x
=0; x
<c
.length
; x
++){
System
.out
.print(c
[x
]);
}
System
.out
.println("");
}
}
例
:有返回值的方法
public class MethodDemo02{
public static void main(String
[] args
){
int one
= addOne(10, 20);
float two
= addTwo(10.3f, 13.3f);
System
.out
.println("add0ne的计算结果: " + one
);
System
.out
.println("addTwo的计算结果: " + two
);
}
public static int add0ne(int i，
int i1
){
int temp
= 0;
temp
=i
+i1
;
return temp
;
}
public static float addTwo(float x
, float y
){
float temp
= 0;
temp
=x
+y
;
return temp
;
}
}
重载方法
方法的重载就是方法名称相同，但参数的类型和和参数的个数不同（只是方法的返回值类型不同不是方法重载），通过传递参数的个数及类型的不同以完成不同功能的方法调用
public class MethodDemo {
public static void main(String
[] args
){
int one
= add(10, 20);
int two
= add(10, 20, 30);
float three
= add(10.3f, 13.3f);
System
.out
.println("add(int x, int y)的计算结果:"+ one
);
System
.out
.println("add(int x, int y, int z)的计算结果:"+ two
);
System
.out
.println("add(float x, float y)的计算结果:"+ three
);
}
public static int add(int x
, int y
){
int temp
= 0;
temp
=x
+y
;
return temp
;
}
public static int add(int x
, int y
, int z
){
int temp
= 0;
temp
=x
+y
+z
;
return temp
;
}
public static float add(float x
, float y
) {
float temp
= 0;
temp
=x
+ y
;
return temp
;
}
}
结果
add(int x
, int y
)的计算结果
:30
add(int x
, int y
, int z
)的计算结果
:60
add(float x
, float y
)的计算结果
:23.6
System.outprintln0方法也属于重载方法。
从前面的内容中可以知道屏幕打印语句System.out.print()方法可以打印任何的数据，如
System.out.println(3); //输出整数
System.out.println(33.3); //输出浮点数
System.out.println(‘3’); //输出字符
System.out.println(true); //输出布尔型
System.out.printIn(3 + 3); //输出计算结果
可以发现程序可以打印数字、小数、字符、布尔类型等各种各样的数据，也就是说printIn()方法被重载了。
方法的递归调用
* 递归调用是一种特殊的调用形式，是方法自己调用自己，如图所示：
例如，要完成一个数字的累加操作，除了可以使用之前的循环方式外，还可以使用递
归调用。
范例
:递归调用
public class MethodDemo04{
public static void main(String args
[]){
System
.out
.println("计算结果: " + sum(100));
}
public static int sum
(int num
){
if(num
==1){
return 1;
}else{
return num
+ sum(num
- 1);
}
}
}
计算结果：
5050
上面程序完成了递归方法的调用，就相当于
100+sum(99)+sum
+(98)+...+
sum(1),
从程序的
sum()方法中可以发现，递归调用时必须有一个明确的结束条件，
然后不断改变传入的数据，才可以实现递归调用。
类的构造方法
在类中除了成员方法之外，还存在一种特殊类型的方法，那就是构造方法。构造方法是一个与类同名的方法，对象的创建就是通过构造方法完成的。每当类实例化一个对象时，类都会自动调用构造方法。构造方法的特点 ：（1）构造方法没有返回值 ；（2）构造方法的名称要与本类的名称相同。在定义构造方法时，构造方法没有返回值，但这与普通没有返回值的方法不同，普通没有返回值的方法使用 public void methodEx() 这种形式进行定义，但构造方法并不需要使用 void 关键进行修饰。语法：
public book
(){
}
在构造方法中可以为成员变量赋值，这样当实例化一个本类的对象时，相应的成员变量也将被初始化。如果类中没有明确定义构造方法，编译器会自动创建一个不带参数的默认构造方法。具体用法，代码实现。 1；单个构造函数方法； 2；多个构造函数方法 （例子为；带参数与不带参数）
对象的创建与使用方法
对象是对类的实例化。对象具有状态和行为，变量用来表明对象的状态，方法表明对象所具有的行为。Java中可以通过new来创建对象，格式如下： 类名 对象名称 = new 类名（）
public class TestClass {
2 public static void main(String
[] args
) {
3
4 Demo d1
= new Demo();
5 Demo d2
= new Demo();
6 Demo d3
= new Demo(003,"AhaBest");
7
8 d1
.id
= 001;
9 d1
.name
= "Aha-Best";
10
11 d2
.setId(002);
12 d2
.setName("Aha_Best");
13
14 System
.out
.println(d1
.id
);
15 System
.out
.println(d1
.name
);
16 d2
.drink();
17 System
.out
.println(d2
.getId());
18 System
.out
.println(d2
.getName());
19 System
.out
.println(d3
.getId());
20 System
.out
.println(d3
.getName());
21 }
22 }
23 class Demo{
24 public int id
;
25 public String name
;
26 public Demo() {
27 super();
28 }
29 public Demo(int id
,String name
) {
30 super();
31 this.id
= id
;
32 this.name
= name
;
33 }
34 public void drink() {
35 String s
="drink";
36 System
.out
.println(s
);
37 }
38 public int getId() {
39 return id
;
40 }
41 public void setId(int id
) {
42 this.id
= id
;
43 }
44 public String
getName() {
45 return name
;
46 }
47 public void setName(String name
) {
48 this.name
= name
;
49 }
50 @Override
51 public String
toString() {
52 return "Demo [id=" + id
+ ", name=" + name
+ "]";
53 }
54 }
