面向对象2

package demo02;
//当一个对象作为方法的参数时，实际上传递进去的是对象的地址值。
public class Demo04PhoneParam {
    public static void main(String[] args) {
        Phone one=new Phone();
        one.brand="魅族";
        one.price="2899";
        one.colour="汝窑白";
        method(one); //传递进去的参数其实就是地址值
    }
    public static void method(Phone param){
        System.out.println(param.price);
        System.out.println(param.brand);
        System.out.println(param.colour);

    }
}

当对象作为方法的参数时

package demo02;
//当使用对象类型作为对象的返回值时，返回值带回的其实就是对象的地址值。
public class Demo05PhoneReturn {
    public static void main(String[] args) {
        Phone two=getPhone();
        System.out.println(two.colour);
        System.out.println(two.price);
        System.out.println(two.brand);
    }
    public static Phone getPhone(){
        Phone one = new Phone();
        one.colour="汝窑白";
        one.price="2899";
        one.brand="魅族";
        return one;
    }

}

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

1.定义的位置不一样

局部变量：定义在方法内部，即大括号内部

成员变量：定义在方法外部，直接定义在在类内

2.作用范围不一样

局部变量：只有在方法中才可以使用，出了方法就不能再用了

成员变量：在整个类中都可以使用

3.默认值不一样

局部变量：没有默认值，要想使用必须先赋值

成员变量：有默认值,规则和数组一样

4.储存的位置不一样

局部变量：储存在栈内

成员变量：储存在堆内

4.生命周期不同

局部变量：随着方法进栈而诞生，随着方法出栈而消失

成员变量：随着对象的创建而诞生 ，随着对象呗垃圾回收而消失。

面向对象三大特征：“封装，继承，多态”

封装：

package demo03;
/*
    面向对象的三大特征：封装，继承，多态。

    封装特性在java中的体现：
    1.方法就是一种封装
    2.关键字private也是一种封装

    封装就是将一些具体的信息隐藏起来对外界不可见

     */
public class Demo02Method {
    public static void main(String[] args) {
        int[] array={10,20,30,50,100};
        int max= getMax(array);
        System.out.println("最大值是："+max);
    }
    public static int getMax(int[]array){
        int max=array[0];
        for (int i = 1; i < array.length; i++) {
            if (array[i] > max){
                max=array[i];
            }

        }
        return max;
    }

}

private关键字的使用以及Getter/Setter方法的使用

package demo03;
/*
问题描述：定义Person类时无法组织不合理的是指被设置进来
解决方案：用private关键字将需要保护的成员变量进行修饰。

一旦使用了private进行修饰，name奔雷当中仍可以随意访问。
但是！超出本类范围之外就不能直接访问了。

间接访问private成员变量，就是定义一对Getter/Setter方法
命名规则：必须叫getXxx/setXxx
对于Getter； 不能有参数，返回值类型与成员变量对应
对于Setter；不能有返回值，参数类型与成员变量一致
get必须有参数无返回，返回值类型要与变量数据类型一致

 */

public class Person {
    String name;
    private int age;
    public void show(){
        System.out.println("我叫"+name+"，年龄"+age);
    }
    //这个方法专用于向age设置数据
    public void setAge(int num){
        if (num<100&&num>0){
            age=num;
        }else{
            System.out.println("数据不合理");
        }
    }
    //这个方法专用于获取age的数据
    public int getAge(){
        return age;
    }
}

package demo03;

public class Demo03Person {
    public static void main(String[] args) {
        Person person= new Person();
        person.show();
        person.setAge(-20);
        person.name="小喵喵";
        person.show();
    }
}

private关键字练习使用

package demo03;
/*
对于基本类型的布尔值setter方法和其他类型规则一致
而Getter方法一定要写成isXxx的形式
 */
public class Student {
    private String name;
    private boolean male;
    private int age;
    public void setName(String str){
        name=str;
    }
    public String getName(){
        return name;
    }
    public void setMale(boolean b){
        male=b;
    }
    public boolean isMale(){
        return male;
    }
    public void setAge(int a){
        age=a;
    }
    public int getAge(){
        return age;
    }
}

package demo03;

public class Demo04Student {
    public static void main(String[] args) {
        Student stu=new Student();
        stu.setName("小喵喵");
        stu.setAge(18);
        stu.setMale(false);
        System.out.println("姓名"+stu.getName());
        System.out.println("年龄："+stu.getAge());
        System.out.println("性别："+stu.isMale());

    }
}

this关键字的作用及使用

package demo04;
/*
当方法的局部变量和类的成员变量重名时，根据“就近原则”优先使用局部变量。
如果粗腰访问奔类中的成员变量，需要的格式
this.成员变量名
“通过谁调用方法，谁就是this”

 */
public class Person {
    String name;  //我自己的名字
    public void sayHello(String name){
        System.out.println(name+"你好。我是"+this.name);
    }

}

package demo04;

public class Demo01Person {
    public static void main(String[] args) {
    Person person=new Person();
    person.name="寇玲玲";
    person.sayHello("曹喵喵");
    }
}

构造方法是专门用来创建对象的方法，当我们通过关键字new来创建对象是，其实就是在调用构造方法
格式
public 类名称(参数类型 参数名称){
    方法体
}

注意事项：
1.构造方法的名称必须和所在类的名称完全一样，连大小写也要完全一样
2.构造方法不要写返回值类型，连void也不写
3.构造方法不能有具体返回值
4.如果没有编写任何构造方法，编译器会自动赠送一个构造方法，没有参数，没有方法体什么事情都不做，
public Student(){}
5.一旦编写了自少一个构造方法，编译器将不再赠送
6。构造方法也是可以进行重载的
重载：方法名称一样，参数列表不同。

定义一个标准类

package demo05;
/*
一个标准的类通常由鞋面四个部分组成

1.为每个成员变量加上private关键字修饰
2.为每个成员变量编写一对Getter/Setter方法
3.编写一个无参的构造方法
4.编写一个全参的构造方法
 */
public class Student {
    private String name;
    private int age;

    public Student() {
    }

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

    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;
    }
}

package demo05;

public class Demo01Student {
    public static void main(String[] args) {
        Student stu1=new Student();
        stu1.setName("曹喵喵");
        stu1.setAge(20);
        System.out.println("年龄："+stu1.getName()+"年龄："+stu1.getAge());
        System.out.println("===================");
        Student stu2=new Student("寇玲玲",22);
        System.out.println("年龄："+stu2.getName()+"年龄："+stu2.getAge());

        stu2.setAge(23);
        System.out.println("年龄："+stu2.getName()+"年龄："+stu2.getAge());
    }

}