# 面向对象
面向过程：更注重操作的步骤 (微观)
面向对象：更注重的参与者（宏观）
**类和对象的关系：**
>类是抽象的，对象是具体的
类是对象类型，对象是类的实例
编写类：类名，属性，方法
使用类：创建对象，给属性赋值，调用方法
**成员变量与局部变量的区别**
| 区别 |成员变量 | 局部变量
|--|--|---|
| 位置不同 | 类中，方法外 |方法里，方法的形参，代码块里
| 作用范围不同 |整个类，整个类中的所有方法均可以使用|只限于当前方法，或者当前语句块
| 内存的存放位置不同 | 存储在堆内存|存储在栈内存
| 有无默认值 |有默认值 |没有默认值
**构造方法(构造器)**
>1.方法名必须与类名相同
>2.不能写返回值，也比能写void，更不能使用return
>3. 构造方法可以重载
**构造方法与成员方法的区别**
| 区别 |构造方法 |成员方法
|--|--|---|
| 作用不同 |用于创建对象，并给属性初始化 |描述对象所具有的行为
|调用/使用方式不同 |使用new关键字调用|使用对象名调用
| 执行顺序不同 | 先执行构造方法创建对象|然后使用对象名去调用成员方法
| 是否开空间 |每执行一次都将在堆中开一个空间 |可以被同一个对象调用N多次，调用一次加载到栈内存一次，执行完出栈
**this关键字**
this代表的是当前对象的引用(地址)
>作用：
>（1）使用本类的属性 this.属性,， this可以省略不写
（2）使用本类的中方法 this.方法（），this可以省略不写
（3）调用本类的其它构造方法 this() ,this(....) ，要求必须是构造方法中第一句代码
（4）用于区分成员变量和局部变量this..代表成员变量
**static关键字**
>(1) static可以修饰成员变量 ,称为静态变量 ，在方法区
>标准 使用方式： 类名.静态变量名
(2)static可以修饰成员方法，称为静态方法
标准使用方式: 类名.方法名();
(3)static 修饰代码块:称为静态代码块， 为类的静态变量进行赋初始值
构造方法，构造代码块,静态代码块执行顺序:
静态代码块>构造代码块>构造方法
(4)修饰内部类 称为静态内部类
**注意事项：
static方法不允许使用成员变量**
**final关键字**
>(1) final修饰的变量称为常量
final修饰成员变量，通常与static一起使用，称为**静态常量**
final修饰的局部变量称为**常量**
final修饰的基本数据类型，其**值**不允许更改
final修饰的引用数据类型, 其**地址**不允许更改
(2)修饰方法 ：不允许子类重写，但是可以被子类调用
(3)修饰类：不允许有子类的，所以称为太监类
**abstract关键字**
>(1)修饰类称为抽象类(特征：就是不能创建对象)
(2)修饰方法 :使用abstract修饰的方法称为抽象方法
抽象方法的特点:
1没有方法体,只能以分号结尾
2.必须定义在抽象类里
3.必须被子类实现，如果子类不实现，那么子类也得是抽象类
注：抽象类里可以包含0个或多个抽象方法，抽象方法必须定义在抽象类中
**interface关键字**
>类与接口的关系 implements（实现）
一个类即存在继承关系又存在实现关系，继承在前(extends),实现在后 (implements)
接口中的变量均为公共的静态常量
java中的类是单继承的，java中的接口是多继承的
**super关键字**
>(1)调用父类的非私有属性
>(2)调用父类的构造方法，要求必须是构造方法中第一句代码
>(3)调用父类的非私有成员方法
>(4)用于父类与子类的同名属性的区分,super指代的是父类,this指代的是子类
**面向对象的三大特征**
>(1)封装:提高程序的安全性
(2)继承:提高代码的复(重复使)用性
(3)多态:提高程序的扩展性
**封装:访问权限**
>public :最大的访问权限
protected :子类方访问权限
package :包内访问权限
private :本类访问权限
**方法重载**
>(1)在一个类里面为一种行为提供多种实现方式并提高可读性
>(2)方法名相同，参数不同（类型不同，个数不同，顺序不同）
**方法重写**
>(1)父类方法无法满足子类的要求，子类通过方法重写满足要求
(2)发生在子类
(3)方法名，参数类型，个数，顺序必须与父类完全相同
(4)子类返回值小于等于父类的返回值
(5)子类访问权限大于等于父类的访问权限
**多态的前提**
>(1)继承是多态的前提
>(2)子类重写父类的方法
>(3)父类引用 new子类对象
**如何使用封装去保证属性的安全性**
>(1)属性私有化 private
(2)提供公有的取值，赋值方法
(3)在赋值的方法中进行值的合理性验证
**封装代码：**
```
/**
* @author lh
* @since JDK 1.8
* ClassName: Person
* date: 2019/8/17 16:37
* Description:
* 定义Person类
* 属性私有化
* 提供共有的取值赋值方法
* 在赋值的方法内进行合理性验证
*/
public class Person {
//属性私有化
private String name;
private int age;
private String gender;
//提供共有的取值赋值方法
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
//在赋值的方法中对值进行合理性验证
if(age<=18||age>=25){
System.out.println("对不起，年龄要在18到25之间");
this.age=18;//给属性设置默认值
}else{
this.age=age;//将局部变量的值赋给成员变量
}
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
//在赋值的方法中对值进行合理性验证
if(!"男".equals(gender)&&!"女".equals(gender)){
System.out.println("对不起，性别有误");
this.gender="男";//给属性设置默认值
}else{
this.gender=gender;
}
}
//无参构造
public Person() {
}
//带参构造
public Person(String name, int age, String gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
//成员方法
public void show(){
System.out.println(name+"\t"+age+"\t"+gender);
}
}
```
```
/**
* @author lh
* @since JDK 1.8
* ClassName: TestPerson
* date: 2019/8/17 16:57
* Description:
* 定义测试类
*/
public class TestPerson {
public static void main(String[] args) {
Person p=new Person();//创建对象（无参）
p.setAge(5);
System.out.println(p.getAge());//对不起，年龄要在18到25之间 设置为18
Person pp=new Person("王小五",22,"人妖");//创建带参构造
pp.show();//提示错误信息 ：对不起，性别有误 王小五 22 男（改为默认值）
}
}
```
**继承代码（一父二字一测试）**
```
/**
* @author lh
* @since JDK 1.8
* ClassName: Animal
* date: 2019/8/17 19:05
* Description:
* 定义一个Animal类
* 定义两个私有属性 color age
* 三个方法 eat sleep introduce
*/
public class Animal {
private String color;
private int age;
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public void eat(){
System.out.println("我饿了，我想吃东西！！！");
}
public void sleep(){
System.out.println("我困了，我想睡觉！！！！");
}
public void introduce(){
System.out.println("Animal:"+color+" "+age);
}
}
```
```
/**
* @author lh
* @since JDK 1.8
* ClassName: Dog
* date: 2019/8/17 19:09
* Description:
* 定义一个dog类
* dog直接继承animal类 ，间接继承object类
* 一个私有属性 name
* 定义一个自己方法
* 覆盖父类的方法
* 重写父类的introduce方法
*/
public class Dog extends Animal {//extend继承 dog类继承animal类
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println("小狗汪汪汪！！！");
}
@Override
public void introduce() {//重写父类的introduce
System.out.println("我是二哈，我会拆家！！！");
}
}
```
```
/**
* @author lh
* @since JDK 1.8
* ClassName: Cat
* date: 2019/8/17 19:14
* Description:
* 定义cat类
* 一个私有属性 name
* 一个方法 show
*/
public class Cat extends Animal {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public void show(){
System.out.println("我会捉老鼠！！！");
}
}
```
```
/**
* @author lh
* @since JDK 1.8
* ClassName: Test
* date: 2019/8/17 19:17
* Description:
* 编写测试类
* 创建两个对象 dog和cat
*/
public class Test {
public static void main(String[] args) {
//dog
Dog dog=new Dog();//创建对象
dog.setName("二哈");
dog.setAge(2);
dog.setColor("黑白相间");
dog.eat();//从父类继承
dog.introduce();//方法重写调用自己的
dog.sleep();//从父类继承
dog.show();//子类自己的
//cat
Cat cat=new Cat();
cat.setColor("橘色");
cat.setAge(3);
cat.eat();
cat.introduce();
cat.sleep();
cat.show();
}
}
```
**多态代码（一父二字一测试）**
```
/**
* @author lh
* @since JDK 1.8
* ClassName: Car
* date: 2019/8/17 20:20
* Description:
* 定义汽车类
* 定义两个方法 run show
* run子类继承
* show子类重写
*/
public class Car {
//子类继承
public void run(){
System.out.println("我在公路上驰骋，不允许飙车！！！");
}
//子类重写
public void show(){
System.out.println("我是辆好车！！！");
}
}
```
```
/**
* @author lh
* @since JDK 1.8
* ClassName: Bwm
* date: 2019/8/17 20:25
* Description:
* 定义bwm类
* 重写父类手方法
* 自己定义speed方法（独有）
*/
public class Bwm extends Car {
//重写父类方法
@Override
public void show() {
System.out.println("我是宝马！！！");
}
//子类特有
public void speed(){
System.out.println("我可以达到200迈");
}
}
```
```
/**
* @author lh
* @since JDK 1.8
* ClassName: Fll
* date: 2019/8/17 20:31
* Description:
* 定义Fll类
* 重写父类show方法
* 自己定义login方法
*/
public class Fll extends Car {
@Override
public void show() {
System.out.println("我是法拉利！！！");
}
public void login(){
System.out.println("我的车标是一匹奔腾的马！！！");
}
}
```
```
/**
* @author lh
* @since JDK 1.8
* ClassName: TestCar
* date: 2019/8/17 20:35
* Description:
* 定义测试类TestCar
* 1.没有使用多态 只能调用父类的方法
* 2.使用多态 父类引用 new子类对象
* 向上类型转换(自动类型转换)
* 只能调用父类中存在的方法,或者是重写的方法
* 在子类中定义的方法将不能使用
* 向下类型转换(强制类型转换) 可以调用子类独有的方法
*/
public class TestCar {
public static void main(String[] args) {
//没有使用多态 只能调用父类的方法
Car c=new Car();
c.run();
c.show();
//使用多态 父类引用 new子类对象
//向上类型转换(自动类型转换)
//只能调用父类中存在的方法,或者是重写的方法
//在子类中定义的方法将不能使用
Car car=new Bwm();
car.show();
//向下类型转换(强制类型转换)
Bwm b=(Bwm)car;
b.speed();//调用子类独有的方法
Car car1=new Fll();//使用多态
car1.show();
Fll f=(Fll) car1;
f.login();//调用子类独有的方法
}
}
```
**接口的使用**
```
/**
* @author lh
* @since JDK 1.8
* ClassName: Human
* date: 2019/8/17 14:14
* Description:
* 定义一个人类的统称
* 定义接口
* 定义三个方法 laugh cry talk
*/
public interface Human {//首先定义什么是人类
//人是快乐的，会笑
public void laugh();
//人类还会哭。代表痛苦
public void cry();
//人类还会说话
public void talk();
}
```
```
/**
* @author lh
* @since JDK 1.8
* ClassName: YellowHuman
* date: 2019/8/17 14:32
* Description:
* 定义具体的人类
* 黄种人
* 重写human接口的三个方法
*/
public class YellowHuman implements Human {
@Override
public void laugh() {
System.out.println("黄种人会笑，开心呀！幸福呀！");
}
@Override
public void cry() {
System.out.println("黄种人会哭，有心事！");
}
@Override
public void talk() {
System.out.println("黄种人会说话，一般都是双字节！");
}
}
```
```
/**
* @author lh
* @since JDK 1.8
* ClassName: WhiteHuman
* date: 2019/8/17 14:37
* Description:
* 定义白种人
* 重写human接口的三个方法
*/
public class WhiteHuman implements Human {
@Override
public void laugh() {
System.out.println("白种人会大笑，侵略的笑声！");
}
@Override
public void cry() {
System.out.println("白种人也会哭！");
}
@Override
public void talk() {
System.out.println("白种人会说话，一般都是单字节！");
}
}
```
```
/**
* @author lh
* @since JDK 1.8
* ClassName: BlockHuman
* date: 2019/8/17 14:42
* Description:
* 定义黑人 类
* 重写human接口的三个方法
*/
public class BlockHuman implements Human{
@Override
public void laugh() {
System.out.println("黑人会笑。");
}
@Override
public void cry() {
System.out.println("黑人也会哭！");
}
@Override
public void talk() {
System.out.println("黑人会说话，一般人听不懂！");
}
}
```
```
/**
* @author lh
* @since JDK 1.8
* ClassName: Test
* date: 2019/8/17 21:06
* Description:
* 定义测试类
* 创建三个实例
* 分别调用自己的方法
*/
public class Test {
public static void main(String[] args) {
Human h=new BlockHuman();
h.cry();
h.laugh();
h.talk();
Human h1=new YellowHuman();
h1.cry();
h1.laugh();
h1.talk();
Human h2=new WhiteHuman();
h2.cry();
h2.laugh();
h2.talk();
}
}
```
**注：一定要理解，理解，理解，多做练习！！！**