面向对象程序设计

1.面向对象概述：类与对象

类（class）

类（Class）是对一类具备相同特征(属性:数据/行为:操作)事物的抽象描述。

类的语法

【修饰符】【类名称】{
【属性的声明】
【方法的声明】
}

public class People{
    String id;
    String name;
    String sex;
    int age;
    boolean marray;
    public void speak(){
        
    }
    public void eat(){
        
    }
}

对象（Object）

对象的创建语法

类名称 引用名 = new 构造器（）；

Student s = new Student();
People p = new People("Tom");

构造器（Constractor）

在对象创建时，用于完成对于对象的一些初始化操作(赋值，资源的开启)。

语法

[修饰符] 类名([参数列数]){

[执行体]

}

public Emp(){		
}
public Emp(int empno){
    eno = empno;
}
public Emp(int empno,String job2){
    System.out.println("构造方法被执行");
    eno = empno;
    job = job2;
}

构造器注意事项

1. 构造器的名称必须跟类名称保持一致
2. 构造器不包含任何类型的返回值（包括void）
3. 一个类中可以存在多个构造器，但是必须保证每个构造器中的参数的个数，顺序或者类型，任意有一项不一致
4. 任何一个类中都存在一个默认的无参构造器；一旦有自定义构造器，则该默认的构造器会被覆盖

信息隐藏

信息隐藏是对象的一种保护机制，使得它的属性或方法不被外部的程序直接访问；外界对类内部定义的数据(对象的成员变量)直接操作会导致数据的错误、混乱或安全性问题

2.面向对象程序设计语言三大特征

特征一：封装

封装是面向对象中最常见的一种也是最简单的，java中通过将一个对象的信息(属性和行为)封装到类中，避免让外界过多的关注类中的实现细节，使得外界访问程序时变得更为简洁。

public class Customer {

	private int id;
	private int vipLevel = 3;
    
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public int getVipLevel() {
		return vipLevel;
	}
	public void setVipLevel(int vipLevel) {
		this.vipLevel = vipLevel;
	}
}

类的封装表现形式通常为：将类中的属性通过private私有化，然后提供public方法以此对外提供访问接口

封装的优点

1. 提高了对象数据的安全性
2. 提高代码的可复用性
3. 提高类的内聚性，降低耦合度

类之间的关系

在实际开发中多数情况下会涉及到多个类之间的协作，因此，类和类之间就必然存在各种各样的关系，面向对象程序设计中，将类之间的关系分为两大类型:

1.横向关系

依赖关系

依赖关系是一种比较紧密的关系，一般表现形式为一个方法的的执行，需要通过另一个对象的支持。
例如：study方法的实现需要student对象的支持，与Course则无关

public class Course{
    
}
public class Student {
	public void study(Course c){
		
	}   
}    

关联关系

关联关系是一种比依赖更为密切的关系，在代码层面的表现形式为，一个类的对象作为属性定义到另一个类中。
例如：图书类对象是作为图书管理员对象的属性定义的

/**图书类*/
public class Book {
	int id;
	String name;
	BookManager manager;
}

/**图书管理员*/
public class BookManager {
	Book[] books;
}

聚合关系

聚合关系是一种比关联关系更为紧密的关系，表现是的两个类之间的一种包含，但是这个包含又不是必须或者不可分割的，从代码层面表现来看，跟关联是一致的，两者之间只是存在语义上的区别

//部门
public class Dept {
	int dno;
	String name;	
}

//员工
public class Emp {
	int eno;
	String name;
	double sal;
	Dept dept;
}

组合关系

组合关系是以上横向关系中最强的关系，表现的是部分跟整体的关系，两者之间通常表现为不可分割的一种关系，但是代码层面的表现跟关联，聚合是一致的，只是一种语义的区别。

public class People {
	Head head;
	Body body;
}
public class Head{
    
}
public class Body{
    
}

2.纵向关系

继承和实现

继承（Extends）是面向对象语言的三大特征之一，体现出的是一种类的上下级关系，因此是一种纵向关系；

特征二：继承

java中通过继承，可以提高类的可扩展性，以及代码的可复用性；继承是一种 is a 的关系

语法

[修饰符] class 子类名 父类名称{

//属性、方法的声明

}

父类

    public class Father {
    	private String firstName;
    	private double money;   	
    	public String getFirstName() {
    		return firstName;
    	}
    	public void setFirstName(String firstName) {
    		this.firstName = firstName;
    	}
    	public double getMoney() {
    		return money;
    	}
    	public void setMoney(double money) {
    		this.money = money;
    	}
    	
    }

子类

    public class Son extends Father{
        
    }

继承注意事项

1. java中一个父类可以存在多个子类
2. 一个子类只能有一个父类(C++允许)
3. Java中虽然不能多继承，但是可以使用多重继承到达多继承目的
4. 子类继承父类之后，子类中可以使用父类的非私有元素(属性，方法) —代码可复用
5. 子类除了可以直接使用父类中的非私有元素外，还可以扩展自己的信息 —代码可扩展性
6. 在创建子类对象时，通常是先调用父类构造器(不是创建父类对象)完成初始化操作，再执行子类构造器完成子类对象的创建以及初始化（调用默认构造器）
7. 如果父类中不存在默认构造器，则子类中需要通过super显式的调用父类的其他构造器
8. 构造器不能被继承，只能被子类调用(初始化子类时)

访问控制

访问权限修饰符：在java中对于元素的访问提供了四种修饰符，分为为：private、default(默认不写)、protected、public；这四种修饰符分别对元素赋予了不同的访问权限

1. private 只允许同一个类的成员访问
2. default 只允许同一个类和同一个包中的成员访问
3. protected 允许同一个类、同一个包以及其子类的成员访问
4. public 为全局变量，所有成员都可以访问

注意事项

1. 以上访问权限修饰符一般可以用于修饰:类，属性，方法
2. 在一个java文件中只能存在一个顶层public 类(不允许使用除public外的其他访问修饰符修饰)
3. 内部类可以使用private和protected修饰

Object类

java.lang.Object是java中所有类的终极父类，即java中所有的类都从该类继承，Object中提供了很多常用的方法:

• toString()
• equals()
• hashCode()
• notify()
• notifyAll()
• wait()

Overload(重载) & Override(重写)

方法的重写和重载都是面向对象程序中多态的一种实现策略。重载和重写都是发生在方法上；

方法重写

子类继承父类后，对父类中的某些方法覆盖，重新实现；在创建子类对象后再调用该方法时，此时使用的就是被重写之后的方法，而不是父类的方法

    public class Animal{
        public void eat(){
            System.out.pritnln("吃食物");
        }
    }
    public class Dog extends Animal{     
        /**方法重写*/
        @Override
        public void eat(){
            System.out.println("吃骨头");
        }
    }

注意事项:

1. 方法的重写发生在继承关系的子类中，一般为子类重写父类的方法
2. 被重写的方法名称必须跟父类方法保持一致
3. 被重写的方法中参数的个数，顺序，类型必须跟父类方法一致，否则，该操作称之为重载而非重写
4. 被重写的方法返回值必须跟父类方法一致
5. 子类中重写的方法访问权限不能小于父类

方法重载

方法的重载是面向对象程序多态的一种实现策略，表现是在同一个类中的多个同名方法的不同体现形式。

    public class PrintDemo {
    	public void write(int i){
    		System.out.println(i);
    	}
    	public void write(float f){
    		System.out.println(f);
    	}	
    	public void write(String s){
    		System.out.println(s);
    	}	
    	public static void main(String[] args) {
    		PrintDemo pd = new PrintDemo();
    		pd.write(3.14F); 
    		pd.write("hello");
    		pd.write(10);
    	}
    }

注意事项

1. 方法的重载一般发生在同一个类或者存在继承关系的多个类中
2. 重载必须要保证被重载方法参数类型，个数，顺序任意有一项不一致
3. 方法的重载跟返回值无关

方法的重写和重载都是多态一种实现策略

特征三：多态

多态是面向对象三大特征中最重要的一种特征，多态可以体现方法层面，方法层面的多态由重载和重写实现；另外多态最重要的体现在变量层面,可以使用一个父类的引用变量指向任何的子类对象，从而实现引用动态绑定机制。

多态实例

    public class Animal{
        String name;
        public Animal(String name){
            this.name = name;
        }
        public void eat(){
            System.out.println(name+"吃东西");
        }
    }
    public class Dog extends Animal{
        public Dog(String name){
            super(name);
        }
    }
    public class Test{
        public static void main(String[] args){
            //父类引用指向子类对象（向上转型）
            Animal a = new Dog();
            //下转型
            Dog d = (Dog)a;
        }
    }

使用多态可以提高程序的可扩展性，多态也称之为动态绑定

可以使用父类引用指向子类对象，但是如果使用子类引用指向父类对象时，操作不当将会导致类型转换异常