Java面向对象

面向对象

面向过程：更注重操作的步骤 (微观)
面向对象：更注重的参与者（宏观）

类和对象的关系：

类是抽象的，对象是具体的
类是对象类型，对象是类的实例

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

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

区别	成员变量	局部变量
位置不同	类中，方法外	方法里，方法的形参，代码块里
作用范围不同	整个类，整个类中的所有方法均可以使用	只限于当前方法，或者当前语句块
内存的存放位置不同	存储在堆内存	存储在栈内存
有无默认值	有默认值	没有默认值

构造方法(构造器)

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

    }
}

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