Java基础——面向基础模块

面向对象基础

1.类和对象

1.1 什么是对象

万物皆对象，客观存在的事物皆为对象

1.2 什么是面向对象

面向一个具体的对象来进行操作(买手机)

1.3 什么是类

类是对现实生活中一类具有共同属性和行为的事物的抽象

类的特点：
类是对象的数据类型
类是具有相同属性和行为的一组对象的集合

1.4 什么是对象的属性

属性：对象具有的各种特征，每个对象的每个属性都拥有特定的值(手机：2999；内存：16G)

1.5 什么是对象的行为

行为：对象能够执行的操作(手机可以用来打电话，发短信)

1.6 类和对象的关系

类：是对现实生活中一类具有共同属性和行为的事物的抽象(人)

对象：是能够看得到摸得到的真实存在的实体(张三)

关系:类是对象的抽象，对象是类的实体

1.7 类的定义

类的重要性：是Java程序的基本组成单位

类是什么：是对现实生活中一类具有共同属性和行为的事物的抽象，确定对象将会拥有的输出和行为

类的组成：属性和行为

属性：在类中通过成员变量来体现(类中方法外的变量)

行为：在类中通过成员方法来体现(和前面的方法相比去掉static关键字即可)

新建模块myClass，在这个模块的src下新建com.myclass包，在这个包下新建类叫phone

package com.myclass;
//此时，/*点回车就会出现多行注释
/*
    类的定义
        类的定义步骤
            定义类
            编写类的成员变量
            编写类的成员方法
    手机类；
        类名：手机(phone)
        成员变量：品牌(brand),价格(price)
        成员方法：打电话(call),发短信(sendMessage)
 */
public class Phone {
    //成员变量
    String brand;
    int price;

    //成员方法
    public void call() {
        System.out.println("打电话");
    }
    public void sendMessage() {
        System.out.println("发短信");
    }
}

1.8对象的使用

package com.myclass;
/*
    创建对象
        格式：类名  对象名  = new 类名()
        范例： Phone p = new Phone();
    使用对象
        1.使用成员变量
            格式：对象.变量名
            范例：p.brand
        2.使用成员方法
            格式：对象名.方法名()
            范例：p.call()
 */
public class phoneDemo {
    //定义main方法
    public static void main(String[] args) {
        //创建对象
        Phone p = new Phone(); //new的都在堆内存，因为在Phone中只有定义，没有给值，所以打印了默认值

        //使用成员变量
        System.out.println(p.brand); //null 堆内存的默认值
        System.out.println(p.price); //0    堆内存的默认值

        //给成员变量赋值
        p.brand = "小米";
        p.price = 3999;
        System.out.println(p.brand);
        System.out.println(p.price);
        //使用成员方法
        p.call();
        p.sendMessage();

    }
}

1.9 案例：学生

在Student.java文件里输入代码

package com.student;
/*
    学生类
 */
public class Student {
    //成员变量
    String name;
    int age;

    //成员方法
    public void study() {
        System.out.println("学习");
    }
    public void doHomeWork(){
        System.out.println("做作业");
    }
}

在StudentDemo.java文件里输入代码：(注意：这两个文件都在同一个包下)

package com.student;
/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        //使用对象
        System.out.println(s.name+","+s.age);  //此时输出的是初始值null,0

        //调用成员变量
        s.name = "张三";
        s.age = 18;
        System.out.println(s.name+","+s.age);
        //调用成员方法
        s.study();
        s.doHomeWork();
    }
}

2.对象内存图

2.1对象内存图(单个对象)

2.2 对象内存图(多个对象)

2.3 对象内存图(多个对象指向相同的内存)

3.成员变量和局部变量

3.1 什么是成员变量和局部变量

成员变量：类中方法外的变量

局部变量：方法中的变量

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

区别	成员变量	局部变量
类中位置不同	类中方法外	方法内或者方法声明上
内存中位置不同	堆内存	栈内存
生命周期不同	随着对象的存在而存在，随着对象的消失而消失	随着方法的调用而存在，随着方法的调用完毕而消失
初始化值不同	有默认的初始化值	没有默认的初始化值，必须先定义，赋值，才能使用

4.封装

4.1 private关键字

Student.java中输入代码：

package com.student;
/*
    学生类
 */
public class Student {
    //成员变量
    String name;
    //int age;
    private int age;

    //提供get/set方法用于获取和设置值
    public void  setAge(int a) {
//        age =a;
        if(a<0 || a>120) {          
            System.out.println("输入年龄有误");
        } else {
            age =a;
        }
    }
    public int getAge() {
        return age;
    }

    //成员方法
    public void show() {
        System.out.println(name+","+age);
    }
}

StudentDemo.java输入代码：

package com.student;
/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();

        s.name = "张三";
        //s.age = 18;
        //s.age = -18; 此时可以直接修改，输出为-18，设置不让外界直接访问变量，做个判断
        s.setAge(-30);
        s.setAge(30);
        //调用show方法
        s.show();

    }
}

4.2 private关键字的使用

一个标准类的编写
1.把成员变量用private修饰
2.提供对应的getXXX()/setXXX()方法

在com包下，新建包student_private，在这个包里新建Student.java和StudentDemo.java

在Student.java的代码如下：

package com.student_private;
/*
    学生类
 */
public class Student {
    //成员变量
    private String name;
    private int age;

    //get/set方法
    public void setName(String n) {
        name = n;
    }
    public String getName() {
        return name;
    }
    public  void setAge(int a) {
        age =a;
    }
    public int getAge() {
        return age;
    }
    public void show() {
        System.out.println(name +","+ age);
    }
}

在StudentDemo.java的代码如下：

package com.student_private;
/*
    学生类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();

        //使用set方法给成员变量赋值
        s.setName("张三");
        s.setAge(18);

        s.show();
        //使用get方法获取成员变量的值
        System.out.println(s.getName()  + "-------" + s.getAge());
        System.out.println(s.getName() + ","+ s.getAge());
    }
}

4.3 this关键字

在com包下，新建包student01，在这个包里新建Student.java和StudentDemo.java

在Student.java的代码如下：

package com.student01;
/*
    学生类
 */
public class Student {
    //成员变量
    private String name;
    private int age;

    //get/set方法
    public void setName(String name) {
        name = name; //在测试项输出为null,18，因为此处传入的name为局部变量
        //this.name = name; //在测试项输出为张三,18,用this修饰的name为成员变量
    }
    public String getName() {
        return name;
    }
//    public  void setAge(int a) {
//        age =a;    //此处的 a与成员变量的age不同名，所以左侧的age就是成员变量，可以不加this修饰
//    }
    public  void setAge(int age) {
        this.age = age;  //此时为标准写法，此时形参与成员变量同名，带this为成员变量
    }
    public int getAge() {
        return age;
    }
    public void show() {
        System.out.println(name +","+ age);
    }
}

在StudentDemo.java的代码如下：

package com.student01;
/*
    学生类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();

        //使用set方法给成员变量赋值
        s.setName("张三");
        s.setAge(18);

        s.show();
    }
}

4.4this的内存原理

4.5 封装

1.封装概述

是面向对象的三大特征之一(封装、继承、多态)

是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的

2.封装原则

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问成员变量private,提供对应的getXxx()/setXxx()方法

3.封装的好处

1.通过方法来控制成员变量的操作，提高了代码的安全性(因为在方法中，是可以对数据进行安全校验的)

2.把代码用方法进行封装，提高了代码的复用性(每次使用，只需要调用就可以了)

5.构造方法

5.1构造方法概述

构造方法是一种特殊的方法

作用：创建对象

在com包下，新建包student02，在这个包里新建Student.java和StudentDemo.java

Student.java的代码如下：

package com.student02;
/*
    学生类

    构造方法
        作用：创建对象
        功能：完成对象数据的初始化

    格式：
       修饰符   类名(参数) {

       }
    修饰符一般用：public
    格式化代码快捷键：ctrl +alt +l
 */
public class Student {
    //定义成员变量
    private String name;
    private  int age;

    //构造方法
    public Student() {
        System.out.println("无参构造方法");
    }

    //定义show()方法
    public void show() {
        System.out.println(name + "，" + age);
    }
}

StudentDemo.java的代码如下：

package com.student02;
/*
    测试类
 */

public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();  //会调用Student里面构造的方法

        s.show();
    }
}

5.2 构造方法的注意事项

在com包下，新建包student03，在这个包里新建Student.java和StudentDemo.java

Student.java的代码如下：

package com.student03;
/*
    学生类
 */
public class Student {
   private String name;
   private int age;

   //手动给出无参的构造方法
   public Student(){}

    //构造方法一
    public Student(String name) {
       this.name = name;
   }
   //构造方法二
    public Student(int age) {
       this.age = age;
    }
    //构造方法三
    public Student(String name,int age) {
       this.name = name;
       this.age = age;
    }



   public void show() {
       System.out.println(name + "，"+age);
   }
}

StudentDemo.java的代码如下：

package com.student03;
/*
    测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s1 = new Student();
        s1.show();

        //用构造方法一创建对象public Student(String name)
        Student s2 = new Student("张三");
        s2.show();

        //用构造方法二创建对象public Student(int age)
        Student s3 = new Student(18);
        s3.show();

        //用构造方法三创建对象public Student(int age)
        Student s4 = new Student("李四",19);
        s4.show();

    }
}

5.3 标准类的制作

在com包下，新建包student04，在这个包里新建Student.java和StudentDemo.java

Student.java的代码如下：

package com.student04;
/*
    成员变量
        使用private修饰
    构造方法
        提供一个无参构造方法
        提供一个带多个参数的构造方法
    成员方法
        提供每一个成员变量对应的setXxx()/getXxx()
        提供每一个显示对象信息的show()
 */
public class Student {
    //成员变量
    private String name;
    private int age;

    //构造方法
    public Student() {}

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

    //成员方法
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public  void  setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    public void show() {
        System.out.println(name + "," + age);
    }
}

StudentDemo.java的代码如下：

package com.student04;
/*
    创建对象并为其成员变量赋值的两种方式
        1:无参构造方法创建对象后使用setXxx()赋值
        2：使用带参构造方法直接创建带有属性值的对象
 */
public class StudentDemo {
    public static void main(String[] args) {
        //无参构造方法创建对象后使用setXxx()赋值
        Student s1 = new Student();
        s1.setName("张三");
        s1.setAge(18);
        s1.show();

        //使用带参构造方法直接创建带有属性值的对象
        Student s2 = new Student("李四",19);
        s2.show();
    }
}