Java面向对象编程重要知识梳理

Java面向对象编程重要知识梳理

一.面向对象概念
将所有预处理的问题抽象为对象，同时了解这些对象具有哪些相应的属性以及行为。以解决这些对象面临的实际问题，这样就在程序开发中应用了面向对象设计的概念，面向对象设计实质上就是对现实世界的对象进行建模操作。
二.面向对象程序设计的特点：
封装性
继承性
多态性
1.分装性：封装是面向对象编程的核心思想。将对象的属性和行为封装起来，其载体就是类，类通常对客户隐藏实现细节，这就是封装的思想。
2.继承性：继承性主要利用特定对象之间共存属性。Java只支持单继承，可以多层继承。
3. 多态性：多态是面向对象程序设计的又一个重要特征。多态是允许程序中出现重名现象。
Java 语言中含有方法重载与成员覆盖两种形式的多态：
方法重载：在一个类中，允许多个方法使用同一个名字，但方法的参数不同，完成的功能也不同。
成员覆盖：子类与父类允许具有相同的变量名称，但数据类型不同，允许具有相同的方法名称，但完成的功能不同。
三.类的声明
1.声明格式：
class 类名称{
数据类型 属性 ；
…. 声明成员变量（属性）
返回值的数据类型 方法名称（参数 1，参数 2…）{
程序语句 ； 定义方法的内容
return 表达式 ；//void类型没有返回值类型
}
}
注1：类中单词的首字母用大写（书写规范）。
2.创建对象(创建多个对象)
格式1：
类名 对象名 =new 类名（）；
例如：Person p =new Person ();//直接实例化对象
格式2：
类名 对象；
对象=new 类名()；
例如：Person p; //先声明一个 Person 类的对象 p
P=new Person(); // 用 new 关键字实例化 Person 的对象 p
对象直接的赋值：
例如：Person p1=new Person();
Person p2=new Person();
Person p3=new Person();
P1=p2;//此时p1指向p2对象的地址，具有与p2一样的内容；
P2=p3;
3.访问对象中的变量或方法
格式1：
访问属性：对象名称.属性名； 例如：p.name;
访问方法：对象名称.方法名()； 例如：p.fun();
4.创建对象数组
（1）格式1
类名 []对象名 =new 类名[n]；
例如：Student p1[] = new Student[5];// Student类创建一个对象数组p1并实例化其长度为5；
（2）格式2：
类名 []对象；
对象=new 类名[n]；
Person p[] ; // 声明 Person 类类型的数组变量
p = new Person[3] ; // 用 new 分配内存空间
注：对象数组可以利用 for 循环来完成对象数组内的初始化操作，此方式属于动态初始化：
for(int i=0;i<p.length;i++) {
p[i] = new Person() ;
}
（3）采用静态方式初始化对象数组：
Person p[] = {new Person(),new Person(),new Person()} ;
5.This关键字的使用
This表示当前对象，当前对象就是指调用类中方法或属性的那个对象。

例如：
public Person(String name,int age)
{
this.name = name ;
this.age = age ;
}
This调用构造方法：
例如：
public Person(String name,int age)
{
// 调用本类中无参构造方法
this() ;
this.name = name ;
this.age = age ;
System.out.println(“2. public Person(String name,int age)”);
}
注：构造方法是在实例化一对象时被自动调用的，也就是说在类中的所有方法
里，只有构造方法是被优先调用的，所以使用 this 调用构造方法必须也只能放
在构造方法的第一行。

6.static关键字
（1）使用static修饰的变量称为静态变量，静态变量属于类所有的。
（2）使用static修饰的常量为静态常量。
（3）使用static修饰的方法为静态方法。（如果想要使用类中的成员方法，就必须先将这个类进行实例化，有时不想创建或者无法创建类的对象时，还要调用类中的方法才能够完成业务逻辑，此时就可以用静态方法）。
在使用static类型声明的方法时需要注意的是：如果在类中声明了一static类型的属性，则此属性既可以在非 static 类型的方法中使用，也可以在 static类型的方法中使用。但用 static 类型的属性调用非 static 类型的属性时，则会出现错误。
例如：
（1）静态变量：static int x；static String=“中国”；(修改静态变量：类名.变量名=值；例如：Person.String=”美国”)
（2）静态常量：static PI=3.1415926；（给静态常量命名时所有字母都是大写）；
（3）静态方法：
public class StaticMethod{
static public void show（形参）{//方法主体}；
public static void main(){
StaticMethod.show();//使用类名调用静态方法（静态方法使用类名调用）
}
}
（4）静态代码块
只用static关键字修饰的代码块，例如：
static{
System.out.println(“static”);//方法主体
}
注：静态代码块由始至终只运行一次 ，静态代码块经常用来进行类属性的初始化；静态代码块最优先被调用。

7.成员变量
格式1：
数据类型 变量名 //例如：int number
格式2
数据类型 变量名=值 //例如：int numbe= 6; String name=”张三”；
注：如果不为变量初始化则默认值为Java中对的默认值。如下表：
数据类型 默认值 说明
byte、short、int、long 0 整形0
float、double 0.0 浮点0
char ‘’ 空格字符
boolean false 逻辑假
引用数据类型,如String null 空值
8.成员方法
格式：
极限修饰符 返回值类型 方法名（参数类型 参数名）{
…//方法主体
return 返回值
}
极限修饰符：private,protected,public
注：定义方法时如果没有极限修饰符，方法的访问权限为默认（即只能在本类及同一个包的类中进行访问）。
9.成员方法的参数
方法的从参数有三种:值参数、引用参数、不定长参数。
（1）值参数
实参与形参之间按照值传递。
在方法中对值类类型的形参的修改并不会影响实参。
例如：
int x=10;
int y=10
public int add(int x,int y){
x=x+y;
return x;
}
System.out.println(“x=”x);
System.out.println(add(x,y));
结果：x=10
20
（2）引用参数
在方法中对值参数的修改会反映到原有的参数上，这种类型的方法参数，称为引用参数。
例如：数组的传递、对象的传递；
（3）不定长参数
声明方法时，如有若干个相同类型的参数，可以定义为不定长参数，声明如下：
极限修饰符 返回值类型 方法名（参数类型… 参数名）
注：…为三个点，不是其他的数量或符号。不定长参数必须是方法中的最后一个参数，任何其他参数必须在它前面。
例如：public void fun(int x,int y,int… z){}

10.构造方法
（1）格式1：（有参构造方法）
public 类名（参数类型 参数）{ //public修饰类名，类名即为构造方法的名称
}
（2）格式2：（无参构造方法）
public 类名（）{ //public修饰类名，类名即为构造方法的名称
}
构造方法的特点：
（1）没有返回值，但也不能定义为void。
（2）名称与本类名相同。
（3）完成对象的初始化，把对象的参数传递给对象成员。
（4）每当实例化一个对象都会自动调用构造方法。
（3）构造方法的私有（单态设计或单链设计）
例如：
（例1：类内调用）
01 public class TestSingleDemo1 {
03 private TestSingleDemo1() {
05 System.out.println(“private TestSingleDemo1 .”) ;
06 }
07 public static void main(String[] args) {
09 new TestSingleDemo1() ;//同属一个类，可以直接调用私有构造方法；
10 } }
输出结果：
private TestSingleDemo1 .
（例2：类外调用）
class Person {
String name ;
// 在本类声明一 Person 对象 p，注意此对象用 final 标记，表示不能再重新实例化
private static final Person p = new Person() ;
private Person() {//声明私有构造函数
name = “张三” ;}
public static Person getP() {//获得对象p的方法
return p ; } }
public class TestSingleDemo2 {
public static void main(String[] args){// 声明一 Person 类的对象
Person p1= null ; p1 = Person.getP() ;
System.out.println(p1.name) ; } }
四、类的封装性
（1）封装类中的属性和方法
格式：
封装属性：private 属性类型 属性名
封装方法：private 方法返回类型 方法名称（参数）
注意：
用 private 声明的属性或方法只能在其类的内部被调用，而不能在类的外部被调用，读者可以先暂时简单的理解为，在类的外部不能直接用对象去调用 private声明的属性或方法。要设置或取得属性值，则只能用 setXxx()、getXxx()方法，这是一个明确且标准的规定。例如：p.getXxx()才能在外部调用。
当成员或方法封装后只能在本类中直接获得，外部的类没有办法直接获得。
五.类的继承
1.格式声明（extends关键字）：
class 父类 // 定义父类
{ }
class 子类 extends 父类 // 用 extends 关键字实现类的继承
{ }

注：子类在继承父类时，会继承父类中的所有属性和方法。包括private类型的，只是在子类中不能直接访问。

如果当父类的方法被封装，通过内部方法的调用类实现其调用。如下
01 class Person
02 {
03 private String name ;
04 private int age ;
05 private void talk()
06 {
07 System.out.println(“我是：”+name+"，今年："+age+“岁”);
08 }
09 public void say()
10 {
11 talk();
12 }
13 public void setName(String str)
14 {
15 name = str ;
16 }
17 public void setAge(int a)
18 {
19 if(a>0)
20 age = a ;
21 }
22 public String getName()
23 {
24 return name ;
25 }
26 public int getAge()
27 {
28 return age ;
29 }
30 }
31
32 public class TestPersonDemo5
33 {
34 public static void main(String[] args)
35 {
36 // 声明并实例化一 Person 对象 p
37 Person p = new Person() ;
38 // 给 p 中的属性赋值
39 p.setName(“张三”) ;
40 // 在这里将 p 对象中的年龄属性赋值为-25 岁
41 p.setAge(30) ;
42 // 调用 Person 类中的 say()方法
43 p.say() ;
44 }
45 }

2.方法的重写
继承不只是扩展父类的功能，还可以重写父类的成员方法。
（1）保留父类的成员方法名称，重新编写成员方法的实现内容。
（2）更改成员方法的存储权限，修改成员方法的返回值类型。
重构：子类与父类的成员方法的返回值、方法名、参数类型及个数完全相同，唯一的不同是实现的内容。这种特殊的重写方式称为重构。
注：重写时不能降低方法的修饰权限范围。

3.super关键字
super关键字带代父类的对象。（this代表本类的对象）

（1）使用格式：
super.属性；//调用父类的属性
super.方法名（形参）；//调用父类的方法
例如：super.name;//调用父类中的name属性
super.fun();//调用父类中的fun()方法
注1：如果在子类构造方法中使用类似super的构造方法，其他初始化代码只能写在super（）之后，不能写在前面，否则会报错。
注2：Java编辑器会在子类的构造方法中自动调用父类的无参构造方法，但有参构造方法并不能自动被调用，只能依赖于super关键字的显式调用父类的构造方法。

4.Object类
Object类为所有类的父类。

5.final关键字
（1）final修饰的方法不能被子类复写；
（2）final修饰的类不能被继承；
（3）final修饰的变量即为常量，只能赋值一次。
六、类的多态性
1.方法的重载
（1）参数个数不同；
（2）参数类型不同；
（3）参数顺序不同；（在有多个参数且类型不同的）
（4）返回值类型不同。

2.向上转型
父类对象通过子类对象去实例化，实际上就是对象的向上转型。向上转型是不需要进行强制类型转换的，但是向上转型精度会丢失。
例如：Person(父类) p = new Student(子类)();

3. 向下转型
   父类的对象转为子类的对象，需要强制转型。
   例如：Student p = (Student)new Person();
   注：
   （1）向上转型可以自动完成；
   （2）向下转型必须进行强制类型转换

4.instanceof关键字
可以使用instanceof操作符判断是否实现了某个接口，也可以用来判断一个对象是否属于一个类。其返回值为boolean类型。
例如：
P1 instanceof Person
返回true说明p1对象为Person的实例对象；返回false说明p1象不是Person的实例对象。

七、抽象类与接口

1.抽象类与抽象方法
（1）抽象类定义规则：

• 抽象类和抽象方法都必须用 abstract 关键字来修饰。
• 抽象类不能被实例化，也就是不能用 new 关键字去产生对象。
• 抽象方法只需声明，而不需实现。
• 含有抽象方法的类必须被声明为抽象类，抽象类的子类必须复写所有的
• 抽象方法后才能被实例化，否则这个子类还是个抽象类。