Java面向对象

Java面向对象

什么是面向对象

现实世界就是“面向对象的”，任何存在的事物都可以看作“对象”。

面向对象就是采用“现实模拟”的方法设计和开发程序，实现了虚拟世界和现实世界的一致性，符合人们的思维习惯，使客户和软件设计开发人员之间、软件设计开发人员内部交流更加流畅，同时有代码重用性高、可靠性高等优点，大大提高了软件尤其是大型软件的设计和开发效率。

面向对象设计三步骤：

1. 发现类。

2. 发现类的属性。

3. 发现类的方法。

面向对象设计的过程就是抽象的过程。

类和对象的关系

类(Class)和对象(Object)是面向对象中的两个核心概念。类是对某一类事物的描述，是抽象的、概念上的定义。对象是实际存在的、具体的事物个体。

类的三大特性：封装、继承、多态

访问修饰符：public、protected、friendly(默认的)、private

常量

常量修饰符：final，可以用来修饰变量、方法、类。

修饰的变量：只能初始化一次值。

修饰的方法：不能被重写，可以重载。

修饰的类：禁止被继承，密封类。

如：

final a = 0;
a = 1;	//error,常量只能被初始化一次

静态

静态修饰符：static，可以用来修饰变量、方法、代码块、类，static修饰的成员属于这个类所有，即由这个类创建的所有对象共用同一个static变量。通常把static修饰的属性和方法称为类属性和类方法。不使用static修饰的属性和方法属于单个对象，通常称为实例属性和实例方法。

修饰的代码块：如

static{
    //代码块
}

注意：

1. 在加载类的过程中，完成静态变量的内存分配，在执行静态块，两者都在创建对象之前执行的。

2. 类属性和类方法可以通过类名和对象名访问，实例属性和实例方法只能同故宫对象名访问。

3. 类方法只能访问类属性和其他类方法

4. 静态方法中不能使用this和super关键字。

修饰的变量：如

static int a = 0;

注意：static修饰的变量是属于类的，不能是局部变量，是所有对象共用的。

修饰的方法：如

public static void showInfo(){ //访问修饰符 static 返回值类型 方法名(){}
    //方法体
}

注意：在方法体中是不能用static关键字。

修饰的类：如

public class A{
    public static class B{
        //方法体
    }
}

注意：1. static修饰的类是内部类，普通类是不能用static修饰的，只能是内部类。

2. 如果内部类没用static修饰，是不能直接new 对象的。

构造方法及其重载

构造方法的作用：用来创建对象的，并给属性赋值。

构造方法的语法：

public class A(){
    public A(){	//访问修饰符 类名(){}
        //构造方法体
    }
}

注意：构造方法没有返回值类型，如果有返回值类型就是方法。并且名称和类名相同。

重载：如

public class A(){
    public A(){}
    public A(int i){}
}

注意：构造函数的重载，方法名相同，参数列表不同。

方法的重载也是一样的。

总结重载的特点：

1. 必须在同一个类中，

2. 方法名相同，

3. 参数列表（方法参数的个数或参数类型）不同，

4. 与返回值类型和方法修饰符没有任何关系。

封装

Java的封装就是将属性私有化，提供公开的get，set方法进行访问。如

private int age;
public int getAge(){	//get方法，进行使用age值
    return age;
}
public void setAge(int age){	//set方法，为私有的age赋值
    this.age = age;
}

封装的好处：隐藏类的实现细节，让使用者只能通过程序规定的方法来访问数据，可以方便地加入存取控制语句，限制不合理操作。

继承和多态

多态：一种事物的多种形态

实现多态的方式：重写和重载

继承的定义：子承父，子类继承父类的所有非private成员。

父类也被称为：基类

子类也被称为：派生类

语法：

public class A extends B{ //A继承B 子类类名 extends 父类类名
    //类定义部分
}

继承的特性：

1. 单根性：有且只有一个父类。
2. 传递性：A继承B，B继承C，A继承C

注意：所有未显著表明父类的类，有一个公共的父类Object。

访问修饰符的限制：

访问修饰符	本类	同包	子类	其他
private	√
friendly(默认)	√	√
protected	√	√	√
public	√	√	√	√

构造方法的调用

在继承关系中构造函数的调用：

调用顺序：调用子类构造函数时，一定会调用父类构造函数，先父类后子类。

this：表示当前类对象的引用

super：表示当前类的父类成员的引用

怎么显式调用构造函数：

public class A{
    public A(){}
    public A(int i){}
}
public class B extends A{
    public B(){
        super();
    }
    public B(int i){
        super(i);
    }
}

注意：在构造函数中，super()或this()只能位于第一行。

this()：表示调用本类的构造函数

super()：表示调用本类的父类的构造函数

重写

重写实现了多态，多个类之间的多态。

前提：

1. 一定有继承关系
2. 在不同的类中
3. 方法名相同
4. 参数相同

子类重写父类的方法，如：

public class A{
    public void showInfo(){
        System.out.println("A");
    }
}
public class B extends A{
    public void showInfo(){
        System.out.println("B");
    }
}

方法重写必须满足的要求：

1. 重写方法和被重写方法必须具有相同的方法名
2. 重写方法和被重写方法必须具有相同的参数列表
3. 重写方法的返回值类型必须和被重写的返回值类型相同或是其子类，即子类 小于等于 父类
4. 重写方法的不能缩小被重写方法的访问权限，即子类 大于等于 父类
5. 抛出异常时，和返回值类型相似，子类 小于等于 父类。

抽象类

抽象类中可以定义抽象方法，都是同过关键字abstract来修饰

如何定义抽象类：

public abstract class A{
    public abstract void showInfo();
} 

注意：

1. 抽象类是不能被实例化的
2. 抽象方法只有方法声明，没有方法实现
3. 抽象类中可以有非抽象方法
4. 继承抽象类的子类，必须重写父类的抽象方法，除非子类也是抽象类

instanceof运算符

Java提供了instanceof运算符来进行类型的判断。

语法：

对象 instanceof 类或接口

instanceof运算符用来判断一个对象是否属于一个类或实现一个接口，接口为true或false。

接口

实现接口

接口是一种规范和标准，它们可以约束类的行为，是一些方法特征的集合，但是没有方法的实现。定义语法和类实现接口语法如：

[修饰符] interface 接口名 extends 父接口1,父接口2,.....{
    //常量定义
    //方法定义
}

class 类名 extends 父类名 implements 接口1,接口2,...{
    //类成员
}

注意：

1. 接口的命名规则于类相同，如果修饰符是public，则该接口在整个项目中可见，如果省略修饰符，则该接口只在当前包可见。
2. 接口中可以定义常量，不能定义常量。接口中的属性都会自动用public static final修饰，即接口中的属性都是全局静态常量，必须在定义是指定初始值。
3. 接口中所有方法都是抽象方法。方法也是都是自动用public abstract修饰，即接口中只有全局抽象方法
4. 和抽象类一样，接口也不能实例化，接口中不能有构造函数
5. 接口之间可以用extends实现继承关系，一个接口可以继承多个接口，但是接口不能继承类。
6. 接口的实现类，必须实现接口的全部方法，否则必须定义为抽象类。

一个类只能有一个直接父类，但是可以通过implements实现多个接口，这就是所说的单继承，多实现。在类继承父类的同时又实现了多个接口时，extends关键字必须位于implements关键字之前

使用C#实现接口

同样C#也是可以实现接口的，语法如：

class 类名:父类名,接口1,接口2,....{}

注意：Java实现接口和C#实现接口的异同：

1. Java中接口通过extends来继承父接口，类通过implements实现接口;C#中通过冒号”：“来实现这两个功能
2. Java接口中的成员变量都是常量，自动用public static final修饰；C#接口中不允许存在成员变量，但可以有属性
3. Java接口中属性和方法都可以使用public修饰；C#中默认为public，但不允许显式使用public修饰
4. Java接口中可以定义静态常量和方法，C#接口中不允许包含任何静态成员

接口和抽象类的区别

相同点：

1. 都不能被实例化
2. 都是约束子类必须实现抽象方法，除非子类也是抽象类

不同点：

1. 关键字：抽象类abstract，接口interface
2. 接口只能有抽象方法，抽象类可以有非抽象方法
3. 接口不能有构造函数，抽象类可以有构造函数
4. 抽象类可以有非静态成员变量，可以不是常量