Java学习之面向对象三要素

面向对象三要素

一、什么是面向对象
面向对象程序设计（object oriented programming 简称OOP）
对象是一个由信息（变量）及对信息进行处理（方法）的描述
其本质是对现实事物的特征和变化规律建立的模型
二、封装
细节（变量和方法）隐藏，成员变量设置为私有（private），然后提供set和get方法来读和取。通俗的讲，封装就是不允许直接访问成员变量，必须通过set和get方法来访问；
优点：安全，便于重构

1. 良好的封装能够减少耦合。
2. 类内部的结构可以自由修改。
3. 可以对成员变量进行更精确的控制。
4. 隐藏信息，实现细节。
   实例：

public class Kid {
	private int age;
	public int getAge() {//通过get方法获取变量值
		return age;
	}
	public void setAge(int age) {//通过set方法，将入参赋值给变量
		this.age 	= age;
	}
}

1、this关键词
this关键字，表示当前类的对象
一般只有在方法中，成员变量名和局部变量名重名的时候，用this来指定成员变量，参考上面示例的setAge方法。
2、访问控制修饰符
访问控制修饰符，用来控制访问权限，一共有四个

三、继承
通过关键字extends来声明子类与父类的继承关系，子类 extends 父类
实例：

public class Kid extends Person{}

特点：

1. 所有类都有父类，即所有类都派生于Object类
2. 只能单亲继承，即每一个子类只能有一个父类
3. 子类只能继承父类的非private修饰的变量和方法
   子类不能继承父类的私有属性，
   如果子类中公有的方法影响到了父类私有属性，
   那么私有属性是能够被子类使用的（即通过父类的公有方法访问到父类的私有变量）
4. 子类可以直接使用继承的变量和方法，不需要再在子类中声明或写出
   1、构造方法
   构造方法（又叫构造器）是一种特殊的方法，它的作用是在创建对象的时候 ，完成对象成员变量的初始化。
   特点：
5. 方法名与类名一致
6. 没有返回值也没有void
7. 通过new关键字调用
8. 当一个类没有显示的声明构造方法时，java会默认创建一个无参构造方法
9. 构造方法可以重载
   示例：

public class Kid extends Person{
	private int age;
	public Kid() {//无参构造方法
		
	}
	public Kid(int age) {//有参构造方法
		setAge(age);
	}
	public void setAge(int age) {
		this.age = age;
	}
}

2、super关键词

public Kid() {//无参构造方法
super();//调用父类构造方法
}
public void setAge(int age) {
super.password = "123";//调用父类变量并赋值
	this.age = age;
}

3、重写
类继承了父类的方法，对父类的方法中的执行代码进行修改以满足子类业务的需要，这就是重写。
特点：

1. 重写发生在子父类当中
2. 方法名、参数列表、返回值类型均相同
3. 重写的方法，方法体不同或者访问控制修饰符不同
4. 子类方法的访问权限不能缩小
5. 静态方法（static）不能进行重写（因为静态资源只加载一次）
   示例：

public class Father {
	public void speak() {
		System.out.println("i am father!!!");
	}
}
public class Son extends Father{
	@Override
	public void speak() {
		System.out.println("i am son!!!");
	}
}

4、重写和重载的区别

四、多态
没有继承就没有多态，生成的对象，在调用父类方法时，如果父类被子类重写，则调用的是子类的方法。
代码当中体现多态性，其实就是一句话： 父类引用指向子类对象
格式：父类 对象名 = new 子类();
1、抽象类
关键字abstract
1） 抽象类不能实例化，及抽象类不能创建类的对象
2） 子类继承（extends）抽象类，必须实现该抽象类当中所有的抽象方法
3） 抽象类，可以包含抽象方法和非抽象方法
4） 如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则出现编译错误
5） 抽象类可以有父类，但父类必须有一个无参的构造函数，否则抽象类必须声明一个与父类相同的有参的构造函数
定义方法，但不定义具体的方法
示例：

// 抽象类
public abstract class Person{
String name; 
public abstract void login(String userName, String password);
public abstract void register(String phone);
public void pay() {
System.out.println("支付");
}
}
// 子类
public class User extends Person {
@Override
public void login(String userName, String password) {
// TODO Auto-generated method stub
}
@Override
public void register(String phone) {
// TODO Auto-generated method stub
}
}

2、接口
键字：interface 声明接口 implement 实现接口
接口是接口方法的集合
1） 用interface关键字声明接口
2） 实现类实现implements接口，并重写接口的所有方法
3） 接口只有方法说明没有普通方法，没有变量，可以有静态常量
4） 接口不能自身实例化，用实现类，完成实例
5） 接口可以实现多个，而父类只有一个，（单亲继承），而且必须先继承（extends）后实现（interface）接口
接口的优点
1） 解决java中单亲继承问题（继承只能单亲继承，但一个实现类可以实现多个接口
2） 接口可以实现并行开发
3） 便于重构
示例：

//接口
public interface Father {
//方法签名
public void speak(String str);
}
//实现类
public class User extends Person implements Father,Mother{
@Override
public void speak(String str) {
// TODO Auto-generated method stub
}
}

3、类型转换
向上转型：子类对象 向父类转型

1. 将一个【父类的引用】指向一个子类对象，称为向上转型；此时自动进行类型转换（即可以理解为创建了一个父类类型的子类对象）
2. 通过父类的引用调用的方法，是子类重写或继承父类的方法，而不是父类原本的方法，更不是子类特有的方法；
3. 通过父类的引用无法调用子类特有的方法，即向上转型的子类对象只能调用继承自父类的方法，而不能调用子类独有的方法，方法数量缩小，安全
   示例：

class Kid extends Man
Man man = new Kid();

向下转型：父类对象 向子类转型

父类对象向子类转换需要强制类型转换；

1. 将一个指向子类对象的父类引用赋给一个子类的引用，称为向下转型
2. 只有Object有向下转型的可能
   示例：

class Kid extends Man
Man man = new Man();//创建了一个父类对象
Kid kid = (Kid) man; //强制类型转换，将父类对象强制转换成子类类型