java第2天:类，对象，封装和构造方法

1 面向对象简述

将 {1,3,45,56,78,90}转化为[1,3,45,56,78,90]

1-2 方法1：面向过程

代码块
public class test {
    public static void main(String[] args) {
        int[] array = {1,3,45,56,78,90};
//        打印成[1,3,45,56,78,90]
        System.out.print("[");
        for (int i = 0; i < array.length; i++) {
            if(i==array.length-1){
                System.out.print(array[array.length-1]+"]");
            }
            else {
                System.out.print(array[i]+",");
            }

        }
    }
}

1-2 方法2：面向对象

代码块
import java.util.Arrays;
public class test {
    public static void main(String[] args) {
        int[] array = {1,3,45,56,78,90};
//        打印成[1,3,45,56,78,90]
        System.out.println(Arrays.toString(array));
    }
}

2 面向对象的思想举例

面向对象：把衣服扔进洗衣机
面向过程：自己动手洗衣服
***

3 类和对象的关系

对象是类的实例化
类是抽象的。
对象是类具体的。
***

4 定义一个学生类

public class Student {
    int age = 13;
    String name = "wangsiyu";

    public void study(){
        System.out.println("学生要学习");
    }
}

1.成员变量是直接定义在类当中，在成员方法的里面
2.成员方法的定义不需要写static

5 对象的创建和使用

5-1第一步：导包

1.通常情况下，一个类并不能直接使用，必须实例化对象后才可以使用。
2.导包的格式： import 包名称.类名称
3.对于和当前类在同一包下，导包语句可以省略不写

5-2 创建对象

格式：类名称 对象名 = new 类名称();
Student stu = new Student();

5-3 对象的使用

成员变量的使用：对象名.成员变量
成员方法的使用：对象名.成员方法（）；

5-4 实例化上文的学生类

public class Student {
    int age = 13;
    String name = "wangsiyu";

    public void study(){
        System.out.println("studdy  sdudsla");
    }
}

6手机类的小练习

略

7 一个对象的内存图

8 两个对象使用一个类的内存图

9 两个引用指向同一个对象内存图

10 使用对象类型作为方法的参数

10-1 创建一个学生类

代码块
package demo1;

public class mystudent {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.age=18;
        stu.name="wangsiyu";
        method(stu);
    }
    public static void method(Student stu){
        System.out.println(stu.age);
        System.out.println(stu.name);
        stu.think();
    }
}

10-2实例化学生，将对象作为方法的参数

代码块
package demo1;

public class mystudent {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.age=18;
        stu.name="wangsiyu";
        method(stu);
    }
    public static void method(Student stu){
        System.out.println(stu.age);
        System.out.println(stu.name);
        stu.think();
    }
}

10-3使用对象类型作为方法的参数内存图

11 使用对象类型作为方法的返回值

11-1 创建一个学生类

代码块
package demo1;

public class Student {
    int age;
    String name;

    public void think(){
        System.out.println(name+"学生可以思考");
    }
}

11-2使用学生类的对象作为方法的返回值

代码块
package demo1;

public class mystudent {
    public static void main(String[] args) {
        Student res = method();
        System.out.println(res.age);
        System.out.println(res.name);
    }
    public static Student method(){
        Student stu = new Student();
        stu.name = "nezha";
        stu.age = 12;
        return  stu;

    }
}

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

null	位置	作用域	默认值	内存	生命周期
成员变量	方法外部，直接写在类中	整个类作用域	有默认值，规则和数组一样	堆内存	随对象而生，随垃圾回收消失
局部变量	写在方法内部	只有方法可以调用，出了方法就失效	没有默认值，想使用必须手动赋值	栈内存	随方法进栈而生，随方法出栈消失

13 封装的思想——给一个数组，求最大值

package demo1;

public class getmax {
    public static void main(String[] args) {
        int[] array = {12,34,67,123,34,555,1024,1};
        int res = getMax(array);
        System.out.println("array数组的最大值是"+res);
    }

    public static int getMax(int[] array){
        int max = array[0];
        for (int i = 0; i < array.length; i++) {
            if(array[i]>max){
                max = array[i];
            }
        }
        return max;
    }
}

14 private封装

1.使用了private关键字修饰成员变量，本类中仍然可以访问到该成员变量，但是超出本来之外则不能直接访问该成员变量
2.使用了private关键字修饰成员变量，可以使用Getter和Settter方法来访问，提高代码的安全性

14-1 使用了private，Getter和Setter的类

package demo1;

public class Student {
    private int age;
    String name;

    public void setAge(int res){
        age = res;
    }
    public int getAge(){
        return age;
    }
}

14-2 使用Setter来设置成员变量值，使用Getter来获取值

package demo1;

public class mystudent {
    public static void main(String[] args) {
        Student stu = new Student();
        System.out.println(stu.name);
        System.out.println(stu.getAge());
        stu.setAge(66);
        System.out.println(stu.getAge());
    }
}

15 使用private关键字来定义学生类

注意：布尔值的Setter不变，但是Setter是有区别的。

15-1 定义一个学生类

public class Student {
    int age =18;
    private boolean male =true;

    public boolean isMale() {
        return male;
    }

    public void setMale(boolean male) {
        this.male = male;
    }
}

15-2 获得布尔值，和修改布尔值的私有成员变量

package demo1;

public class ms {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setMale(false);
        System.out.println(stu.isMale());
    }
}

16 this关键字的作用

当方法的局部变量和类的成员变量重名时候，遵循就近原则
使用this.变量名表示使用成员变量
通过谁调用的方法，谁就是this

16-1 定义一个类

package demo1;

public class Student {
    String name = "wangsiyu";

    public void sayhello(String name){
        System.out.println(name+"你好，我是"+this.name);
    }
}

16-2 使用这个类

package demo1;

public class ms {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.name = "mayun";
        stu.sayhello("wangjianlin");
    }
}

17 构造方法

1.当我们使用new创建对象的时候，其实调用的就是构造方法

2.构造方法的名称必须和类名称大小写完全一致

3.构造方法不要写返回值，连void都不要写

4.构造方法不能有返回值

18 定义一个标准的学生类

有私有成员变量
有构造方法
有Getter和Setter.

package demo1;

public class Student {
    private String name;

    public Student(){

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

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