【JAVA笔记】JAVA基础-面向对象04

一、OOP详解

• 面向对象编程（Object-Oriented Programming，OOP）
• 面向对象编程的本质就是：以类的方式组织代码，以对象的组织（封装）数据。
• 抽象
• 三大特性：封装、继承、多态、

1、 class类

我们面向对象，就是把一个一个抽象的事务具象化一个类，然后把属性和行为定义出来。

定义类

public class Cat {
    String name;
    int age;
    
    void eat(){
        System.out.println("小猫吃鱼！");
    }
}

　这就是一个类，小猫的名字和年龄是它本身的属性，吃是小猫的行为　

2、类与对象的关系

类是一种抽象的数据类型，而对象是对这种抽象的类的实例化。

    public static void main(String[] args) {
        Cat cat = new Cat();
        cat.eat();

    }

二.类详解-封装

1、 this关键字

this翻译出来就是这个，每一个类都有一个this，他是一个引用。通常情况下可以省略。
在实例方法中，或者构造方法中，为了区分局部变量和实例变量，不能省略。

 private String name;
 public void setName(String name) {
        this.name = name;
    }

这个时候区分这个this.name代表类种属性的name而不是局部变量。

2 、构造方法

每个类都有一个默认的构造方法，和类名一样的无参构造。
但是如果我们写了一个构造器，系统就不会自动生成无参构造器了

public class Cat {
    private String name;
    int age;
    public Cat() {
      
    }

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void eat(){
        System.out.println("小猫吃鱼！");
    }


}　

alt+insert可以选择constrouctor快速的生成构造方法。构造方法可以重载。

3、封装

一个类的属性不应该完全暴露，不然就会被随意更改，我们需要定义一个方法，通过方法来操作我们的属性，这就是封装的基本理念

1）private强调是自己来使用

2）默认是给同包下的来使用

3）protected 强调的是给子类使用

4）public 强调的是给大家使用

封装的意义：

private 是私有的意思，我们把属性通过private修饰，然后通过方法去取值和赋值，这样对于一些违规的操作我们就可以在方法里进行过滤，比如年龄如果传过来超过一百五十岁这种。

public class Cat {
    private String name;
    private int age;
    public Cat() {

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    void eat(){
        System.out.println("小猫吃鱼！");
    }


}

　　alt+inser也可以快速生成

*延申-封装-可变参数：

基本概念：

java允许将同一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。

基本语法：

访问修饰符 返回类型 方法名(数据类型... 形参名) {}

public class VarParameter {
    public static void main(String [] args) {
    HspMethod Sum = new HspMethod();
    System.out.println(Sum.sum(1,2,3));

    }
}

class HspMethod {
    public int sum(int... nums) {
        //System.out.println("接受的参数个数= " + nums.length);
        int res = 0;
        for(int i = 0; i < nums.length; i++) {
            res += nums[i];
        }
        return res;
    }
}

注意事项和细节

(1)可变参数可以是0个或者任意个。

(2)可变参数的实参可以是数组。

(3)可变参数的本质就是数组。

(4)可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后。

(5)一个形参列表中只能出现一个可变参数。

public class VarParameter {
    public static void main(String [] args) {
    HspMethod Sum = new HspMethod();
    System.out.println(Sum.showScore("小明",90,100));
    }
}

class HspMethod {
    public String showScore(String name, double... score) {
        double totalScore = 0;
        for(int i = 0; i < score.length; i++) {
            totalScore += score[i];
        }
        return name + "的总成绩为：" + totalScore;
    }
}

//小明的总成绩为：190.0

三.类详解-继承

类与类直接可以继承，比如我们定义一个人类，然后男人类和女人类就可以继承人类。完全继承他的属性和方法。还有自己的特定的属性

public class Person {
    private String name;
    private int age;

    public void eat() {
        System.out.println("吃");
    }
}

public class Man extends Person {
    private String huzi;
    
    public void niao(){
        System.out.println("站着尿尿");
    }
}

我们就定义是一个人类，基本上每个人都是有年龄名字和吃的行为，但是男人除了人类的特性，还有胡子和站着尿尿的行为，这样我们为了不重复声明属性和行为，直接继承即可。　　

一个类只能单继承，只能继承一个父类，但是一个父类可以有多个子类。
Object类是所有类的父类。

1、Super关键字

之前介绍了this关键字，是类的引用，Super关键字就是代表父类的引用。

  public void niao(){
        super.eat();
        System.out.println("站着尿尿");
    }

我们子类在尿尿的时候，可以调用父类吃的方法，吃完在尿　

不管是显式还是隐式的父类的构造器,super语句一定要出现在子类构造器中第一行代码。所以this和
super不可能同时使用它们调用构造器的功能,因为它们都要出现在第一行代码位置。

2、方法重写

方法重写是发生在子类中，参数和方法名返回值类型都得相同。

重写 实例：

package com.cnblogs;
//本类用于实现
public class Application {
    public static void main(String[] args) {
        //实例化父类
        Person person = new Person();

        //实例化子类
        Student stu = new Student();

        person.getName();//父类属性
        stu.getName();
        //子类属性
        //父类属性
    }
}

 

package com.cnblogs;
/*
person类
 */
public class Person {
    //父类属性
    private String name = "父类属性";
    //父类方法
    public void getName(){
        System.out.println(name);
    }
}

 

package com.cnblogs;
/*
student类
 */
public class Student extends Person{
    //子类属性
    private String name = "子类属性";
    //子类重写父类方法
    @Override
    public void getName() {
        System.out.println(name);
        //super关键字
        super.getName();
    }
}

四.类详解-多态

定义：父类引用指向子类对象，就是多态

多态的存在要有3个必要条件：要有继承，要有方法重写，父类引用指向子类对象　　

1、多态实例：

Animal 父类：

package cn.itcast.demo7;

//定义父类
public class Animal {
    private String name;

    //    空参构造
    public Animal() {

    }

    //    带参构造
    public Animal(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    //    成员方法
    public void eat() {
        System.out.println("吃饭");
    }
}

Dog 子类：

package cn.itcast.demo7;

//是Animal的子类
public class Dog extends Animal {
    //对父类eat重写
    @Override
    public void eat() {
        System.out.println(getName() + "吃骨头");
    }
}

Mouse 子类：

package cn.itcast.demo7;

//子类-老鼠类
public class Mouse extends Animal {
    @Override
    //对父类eat重写
    public void eat() {
        System.out.println(getName() + "吃奶酪");

    }

}

Test测试类（写法1）：

package cn.itcast.demo7;

public class Test {
    public static void main(String[] args) {

        Animal animal1 = new Dog();
        animal1.setName("哈士奇");
        animal1.eat();

        Animal animal2 = new Mouse();
        animal2.setName("Jerry");
        animal2.eat();

    }
}

测试结果：

哈士奇吃骨头
Jerry吃奶酪

Test测试类（写法1）：

package cn.itcast.demo7;

public class Test {
    public static void main(String[] args) {
//        用来测试Dog类和Mouse类
//        测试Dog类
        Dog d = new Dog();
        d.setName("哈士奇");
        showAnimal(d);

//        用来测试老鼠类
        Mouse m = new Mouse();
        m.setName("Jerry");
        showAnimal(m);

    }

    // 多态的使用场景：父类型可以作为形参的数据类型
    public static void showAnimal(Animal an) {
        an.eat();

    }

}

两种写法返回结果相同　

备注：

1）多态关系中，成员变量不涉及重写
简单记忆：编译看左，运行看左

2）多态关系中，成员方法
简单记忆：编译看左，运行看右

2、多态调用子类独有方法实例：

Animal 父类：

package cn.itcast.demo8;

public class Animal {
    public void eat() {
        System.out.println("吃饭");
    }
}

Dog子类：

package cn.itcast.demo8;

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    public void watch() {
        System.out.println("狗会看家");
    }

}

Test 测试类：

package cn.itcast.demo8;

public class Test {
    public static void main(String[] args) {
//        通过多态创建对象调用子类的方法
        Animal an = new Dog();
//        调用eat()方法
        an.eat();

//        调用watch()方法，属于子类独有的方法
//        an.watch();   不能直接使用

//1、向下转型(调用子类独有的方法）
  /*      Dog dog = (Dog) an;
        dog.watch();*/
//      优化、判断对象是否是Dog对象，如果是再调用watch()方法
        if (an instanceof Dog) {
//能走到这里说明条件满足
            Dog dog = (Dog) an;
            dog.watch();
        }
    }
}

测试结果：　

狗吃骨头
狗会看家