# 面向对象

面向过程：更注重操作的步骤  (微观)

面向对象：更注重的参与者（宏观）

**类和对象的关系：**

>类是抽象的，对象是具体的

类是对象类型，对象是类的实例

编写类：类名，属性，方法

使用类：创建对象，给属性赋值，调用方法

**成员变量与局部变量的区别**

| 区别 |成员变量  | 局部变量

|--|--|---|

| 位置不同 | 类中，方法外 |方法里，方法的形参，代码块里

| 作用范围不同 |整个类，整个类中的所有方法均可以使用|只限于当前方法，或者当前语句块

| 内存的存放位置不同 | 存储在堆内存|存储在栈内存

| 有无默认值 |有默认值 |没有默认值

**构造方法(构造器)**

>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();

    }

}

```

**注：一定要理解，理解，理解，多做练习！！！**