一、对象的属性局部变量和全局变量0711

一、对象的属性

把其他自定义类作为属性

Dog宠物狗

/**
 * 宠物狗
 *  被人类领养
 */
public class Dog {
    private String name; //名字
    private String type; //品种

    //构造器
    public Dog() {
    }
    public Dog(String name, String type) {
        this.name = name;
        this.type = type;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
}

Person人类

/**
 * 人类
 *  人类有宠物狗
 */
public class Person {
    private String name; //姓名
    private Dog dog; //宠物

    //构造器
    public Person() {
    }
    public Person(String name, Dog dog) {
        this.name = name;
        this.dog = dog;
    }

    /**
     * 领养宠物狗
     * @param dog
     */
    public void adoptAPet(Dog dog){//形参 参数是要领养的宠物狗
        System.out.println(this.name+"领养了一条"+dog.getType()+"品种的狗");
        this.dog=dog;//真正领养，把都附加到属性
    }
    /**
     * 给宠物狗起名字
     */
    public void giveName(){//形参 参数是要领养的宠物狗
        System.out.println("-->请输入宠物狗的新名字:");
        String dogName = new Scanner(System.in).next();
        //把名字设置给宠物狗对象
        this.dog.setName(dogName);
    }
    /**
     * 宠物介绍
     */
    public void say(){
        System.out.println("我叫"+this.name+"，我有一条"+this.dog.getType()+"品种的宠物狗，叫"+this.dog.getName());
    }
    //get和set省略..
}

测试使用

/**
 * 测试人类领养宠物狗
 */
public class Test {
    public static void main(String[] args) {
        //创建Dog宠物狗对象
        Dog d1 = new Dog(null, "中华田园犬");
        Dog d2 = new Dog(null, "泰迪");
        Dog d3 = new Dog(null, "藏獒");
        Dog d4 = new Dog(null, "哈士奇");

        //创建人对象
        Person p1 = new Person("井付坤",null);
        Person p2 = new Person("张四康",null);

        //领养环节
        p1.adoptAPet(d1);
        p2.adoptAPet(d4);

        //起个名字
        p1.giveName();
        p2.giveName();

        //人类介绍自己的宠物狗
        p1.say();
        p2.say();
    }
}

二、局部变量和全局变量

1、局部变量：

在方法内的，如参数，方法体内声明的变量

生命周期，只要当前所在位置代码执行结束，就会销毁

public void setName(String name) {//参数name是局部变量
    this.name = name;
    //name=name; //属性是全局变量，会和同名的局部变量冲突？变成局部变量
    			//如何引用被隐藏的全局变量，使用this
}

this就代指当前对象（方法的调用者）

2、全局变量：

直接在类中，属于类的属性，可以在本类的所有实例方法中访问（非static修饰的）

public static void testAccess(){
    //System.out.println(name);//全局实例变量变量不能静态方法中被访问
    //System.out.println(this.name);
}

生命周期，全局变量属于属性，只要对象在，就一直在，等到堆内存的对象被销毁才会销毁

三、值传递和引用传递

值（基本数据类型）在栈内存中

引用（对象）在堆内存中

问题：当我们传参的时候，传出去的数据是否还和原本的变量有关系？

//把对象在堆内存的首地址（位置）保存给不同的变量
int[]brr = {100};

int[]crr = brr;
int[]drr = brr;
//请问：brr、crr、drr，一共几个数组？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6MFGlhy4-1657797117021)(Img\yy.png)]

四、方法重载

在同一个类中，方法名相同，参数不同，可以定义多个同名的方法

根据不同的参数，可以调用不同的方法

• 参数的个数不同
• 参数的类型不同
• 参数的个数相同，类型不同

/**
 * 计算器
 *  加法（不同类型）
 */
public class Calc {

    /**
     * 计算整数的求和
     * @param a
     * @param b
     * @return
     */
    public static int sum(int a,int b){
        return a+b;
    }

    /**
     * 计算整数的求和
     * @param a
     * @param b
     * @return
     */
    public static double sum(double a,double b){
        return a+b;
    }
}

测试使用重载的方法

/**
 * 测试 计算类的求和
 *  体现的是方法的重载
 */
public class Test {

    public static void main(String[] args) {
        //都是求和，共用一个名字，参数不同
        System.out.println(Calc.sum(1,2));
        System.out.println(Calc.sum(1.2,2.2));
    }
}

五、static

类中的属性和方法，称为类的成员

成员分为：实例成员和类成员

1、实例成员

实例成员属于对象，只有对象才能引用和访问

2、类成员

类成员不属于任何对象，所有对象都可以共享和访问，可以直接通过类名和对象名引用和访问

类方法中不能直接访问实例成员

​ 因为实例成员必须由对象引用

​ 而类方法由于也可以被类名直接引用，所以本身是没有对象的，所以无法访问实例成员

3、static静态代码块

用于类加载后的静态属性的初始化

学生类花班费和花自己钱案例

学生类

/**
 * 学生类
 *  姓名、自己的钱、班费
 *
 *  花自己钱的方法 花钱
 *  花班费的方法
 */
public class Student {
    private String name; //学生姓名
    private double money; //自己的钱
    private static double clazzMoney; //班费 类成员

    //static代码块，优先加载，类成员（对类成员初始化）
    static{
        clazzMoney=10000;
    }

    /**
     * 花自己的钱
     * @param money
     */
    public void spendMoney(double money){//通过形参传入要花的金额
        System.out.print(this.name+"原有"+this.money+" ");
        this.money-=money;//花钱
        System.out.println("花了"+money+"，还剩"+this.money);
    }
    /**
     * 花班费
     * @param money
     */
    public void spendClazzMoney(double money){//通过形参传入要花的金额
        System.out.print("班级原有班费"+clazzMoney+" ");
        clazzMoney-=money;//花钱
        System.out.println("花了"+money+"，还剩"+clazzMoney);
    }
    //构造器
    public Student() {
    }
    public Student(String name, double money) {
        this.name = name;
        this.money = money;
    }
	//get和set省略...
}

测试类

/**
 * 测试 实例成员和类成员的区别
 */
public class Test {
    public static void main(String[] args) {
        //创建对象
        Student s1 = new Student("曲滔", 200000000);
        Student s2 = new Student("白依", 500);

        //花自己的钱（个人的钱是实例变量，每个人都有自己的实例变量，和别人的没关系）
        s1.spendMoney(30000000);
        s2.spendMoney(10);

        //花班费（班费是共有的）
        s1.spendClazzMoney(5000);//挪用班费买华为手机
        s2.spendClazzMoney(20);//挪用班费买手机壳
    }
}

运行结果

曲滔原有2.0E8 花了3.0E7，还剩1.7E8
白依原有500.0 花了10.0，还剩490.0
班级原有班费10000.0 花了5000.0，还剩5000.0
班级原有班费5000.0 花了20.0，还剩4980.0

六、封装

概念：把属性设为private，隐藏内部细节限制外部直接访问，提供公共的get和set方法间接访问，提升安全性。

get方法用于获取内部属性

set方法用于设置内部属性的值

七、面向对象三大特点（三大特征）

封装、继承、多态

八、继承

子类继承父类，所有非私有的属性和方法（不包含构造器和主方法）

Java只能单一继承，一个类只能有一个父类（可以通过多重继承来实现多继承）

（所有的类都直接或间接继承了Object，Object万类之祖）

动物继承案例1

/**
 * 动物类
 *  由于不确切是什么动物？所有定义为抽象类
 *
 *  比如：抽象派艺术？abstract
 *      抽象类不能直接实例化
 */
public abstract class Animal {
    //把动物类共有的属性和方法定义到动物类
    //这样话，具体的子类就需要重新定义了，直接继承动物类就可以了
    private String name; //名字

    /**
     * 所有动物都有吃的行为
     *  由于不确切是什么动物，所以定义为抽象方法
     *  具体吃什么需要在子类中实现
     */
    public abstract void eat();

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

/**
 * 猫类，具体的动物
 *  吃鱼
 */
public class Cat extends Animal{//如果子类不是抽象类，必须要实现父类抽象的方法
    /**
     * 所有动物都有吃的行为
     * 由于不确切是什么动物，所以定义为抽象方法
     * 具体吃什么需要在子类中实现
     */
    @Override //重写：父类方法不满足子类使用，子类继承后可以重写
    public void eat() {
        //super在子类中表示父类
        System.out.println(super.getName()+"吃鱼");
    }

}

/**
 * 狗类
 *  啃骨头
 */
public class Dog extends Animal{
    /**
     * 所有动物都有吃的行为
     * 由于不确切是什么动物，所以定义为抽象方法
     * 具体吃什么需要在子类中实现
     */
    @Override
    public void eat() {
        System.out.println(super.getName()+"啃骨头");
    }
}

/**
 * 测试
 */
public class Test {
    public static void main(String[] args) {
        //创建Dog类对象和Cat类对象
        Cat cat = new Cat();
        cat.setName("花花");
        cat.eat();

        Dog dog = new Dog();
        dog.setName("旺财");
        dog.eat();

    }

}

接口：为了弥补类只能单一继承的缺陷，后来演变为一种接口规范

给动物都添加一个功能：跳高 Jump()

​ 定义一个Jump接口，所有需要的这个功能的，都实现这个接口

/**
 * 跳高的规范
 *
 * 接口是更加抽象的抽象类
 *  接口不能实例化，用于作为一种约定（规范）
 *      接口内的属性都是public static final 修饰的常量
 *          double PI=3.14;//默认修饰符就是 public static final
 *
 *      接口内的方法都是抽象的方法
 */
public interface Jump {
    public void jump();
}

/**
 * 猫类，具体的动物
 *  吃鱼
 */
public class Cat extends Animal implements Jump{//如果子类不是抽象类，必须要实现父类抽象的方法
    /**
     * 所有动物都有吃的行为
     * 由于不确切是什么动物，所以定义为抽象方法
     * 具体吃什么需要在子类中实现
     */
    @Override //重写：父类方法不满足子类使用，子类继承后可以重写
    public void eat() {
        //super在子类中表示父类
        System.out.println(super.getName()+"吃鱼");
    }

    @Override
    public void jump() {
        System.out.println(super.getName()+"像猫跳一样跳高..");
    }

    //子类还可以扩展方法
    /**
     * 捉老鼠
     */
    public void catchMouse(){
        System.out.println(super.getName()+"捉老鼠..");
    }
}

/**
 * 狗类
 *  啃骨头
 */
public class Dog extends Animal implements Jump{
    /**
     * 所有动物都有吃的行为
     * 由于不确切是什么动物，所以定义为抽象方法
     * 具体吃什么需要在子类中实现
     */
    @Override
    public void eat() {
        System.out.println(super.getName()+"啃骨头");
    }

    @Override
    public void jump() {
        System.out.println(super.getName()+"像狗跳一样跳高..");
    }

    //子类也可以扩展自己的方法
    /**
     * 狗看家
     */
    public void lookHome(){
        System.out.println(super.getName()+"看家..");
    }
}

/**
 * 测试
 */
public class Test {
    public static void main(String[] args) {
        //创建Dog类对象和Cat类对象
        Cat cat = new Cat();
        cat.setName("花花");
        cat.eat();
        cat.jump();
        cat.catchMouse();

        Dog dog = new Dog();
        dog.setName("旺财");
        dog.eat();
        dog.jump();
        dog.lookHome();
    }
}

花花吃鱼
花花像猫跳一样跳高..
花花捉老鼠..
旺财啃骨头
旺财像狗跳一样跳高..
旺财看家..

多态的案例

​ 概念：

​ 多态=多种形态=多种类型

​ Dog继承了Animal，这个dog对象，我们可以说你是Dog，也可以说你是Animal

​ 然后dog就拥有多种类型=多种形态=多态

什么是多态？

​ 把不同的子类对象都当作共同的父类来看，屏蔽了子类之间直接的差异

​ 可以设计通用的编程，大大提高代码的重用性

饲养员案例描述多态的使用：

/**
 * 有一个动物园，有好多动物，需要吃饭，设计一个饲养员来喂动物
 * 饲养员
 */
public class Feeder {
    private String name; //饲养员名字

    /**
     * 喂狗的方法

    public void feed(Dog dog){
        System.out.println(this.name+"喂"+dog.getName());
        //饲养员喂狗，狗要吃（执行吃的方法）
        dog.eat();
    } */

    /**
     * 喂猫的方法

    public void feed(Cat cat){
        System.out.println(this.name+"喂"+cat.getName());
        //饲养员喂猫，猫要吃（执行吃的方法）
        cat.eat();
    } */

    //改为喂动物（子类共同的类型）
    public void feed(Animal animal){
        System.out.println(this.name+"喂"+animal.getName());
        //饲养员喂动物，动物要吃（执行吃的方法）
        animal.eat();
    }

    public String getName() {
        return name;
    }

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

/**
 * 测试
 */
public class Test {
    public static void main(String[] args) {
        //创建Dog类对象和Cat类对象
        Cat cat = new Cat();
        cat.setName("花花");
        //cat.eat();
        //cat.jump();
        //cat.catchMouse();

        Dog dog = new Dog();
        dog.setName("旺财");
        //dog.eat();
        //dog.jump();
        //dog.lookHome();

        //创建饲养员对象
        Feeder feeder = new Feeder();
        feeder.setName("贾政阳");

        //饲养员要喂动物
        feeder.feed(cat);
        feeder.feed(dog);
    }

}

}

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

}

```java
/**
 * 测试
 */
public class Test {
    public static void main(String[] args) {
        //创建Dog类对象和Cat类对象
        Cat cat = new Cat();
        cat.setName("花花");
        //cat.eat();
        //cat.jump();
        //cat.catchMouse();

        Dog dog = new Dog();
        dog.setName("旺财");
        //dog.eat();
        //dog.jump();
        //dog.lookHome();

        //创建饲养员对象
        Feeder feeder = new Feeder();
        feeder.setName("贾政阳");

        //饲养员要喂动物
        feeder.feed(cat);
        feeder.feed(dog);
    }

}