java零基础入门学习第六天——相关笔记

面向对象

面向：基本义：面对、朝向；引申义：注重、关注

对象：能想到的都是对象，世间一切的事物（万物皆对象）

面向对象思想就是把关注点放在一件事或一个活动中涉及到的人或事物（也就是对象）上的思想（或思维方式）

面对过程思想就是把关注点放在一件事或一个活动中涉及到的步骤（也就是过程）上的思想（或思维方式）

面对过程思想举例：

关键字：步骤、过程

如洗衣服：招盆接水—放衣服—放洗衣液—手洗衣服—晾晒衣服

若缺少一个步骤，洗衣服就完成不了

面向对象举例：

关键字：事物、对象

如洗衣服：给别人帮洗，至于他怎么洗，你不用关心（找到一个对象来执行就可以了）

面向对象：用来提高代码的复用性，安全性，扩展性和可维护性的，使代码更符合实际开发中的要求

面向对象思想特点：

1.是一种更符合人们思考习惯的思想

2.把复杂的事情简单化

3.把人们从执行者变成指挥者

面向对象的程序开发：

就是不断的找对象，使用对象，指挥对象做事情的过程，没有对象，就创建一个

面向对象思想三大特征：封装(encapsulation)、继承(inheritance)、多态(polymorphism)

抽象是封装的基础

类与对象

描述事物从两方面着手

属性：如品牌，型号，名称等事物的状态（外在特征）

行为（功能）：如打电话、发短信、玩游戏等事物的功能

Java中通过“类”来描述事物，类主要由属性和行为构成

类的概念：即归类，分类，是一系列具有相同属性和行为的事物的统称

抽象：把一系列相关事物共同的属性和行为提取出来的过程（分类的过程）

对象：是某一类事物的某个具体存在

类与对象的关系：

类：属性和行为的集合，是一个抽象概念（没有明确的表明是什么）

对象：是该类事物的具体体现，是一种具体存在

举例：

手机—>类； 手中的华为手机—>对象

电脑—>类； 我的联想电脑—>对象

自定义类是引用类型

如何定义一个类：定义类的过程，就是把一系列相关事物共同的属性和行为抽取出来的过程

成员变量：事物的属性

成员方法：事物的行为（功能）

举例：

事物：

属性：品牌；型号；名称 行为：打电话；发信息；玩游戏

类：

成员变量：brand;model;name 行为方法：call(); sendMessage(); playGame()

如何创建一个对象？

类名 对象名 = new 类名();

如何使用一个对象？

对象名.变量名

对象名.方法名(实参)

手机类的定义和使用

定义

String：字符串，“HelloWorld”、“程序猿”

注意事项：成员变量定义在类中、方法外；成员方法去掉static修饰符

类名：Phone

成员变量：String brand; //品牌 String model; //型号 String name; //名称

成员方法：call(); //打电话 sendMessage(); //发短信 playGame(); //玩游戏

使用

Phone p = new Phone();

//……

案例：

package study2.demo;
/*
定义一个手机类
 */
public class Phone {
    //成员变量：定义在类中，方法外的变量
    //品牌
    String brand;
    //型号
    String model;
    //名称
    String name;
    //成员方法：先不写static修饰符
    //打电话
    public void call(String name) {
        System.out.println("给"+name+"打电话");
    }
    //玩游戏
    public void playGame(String name) {
        System.out.println("和"+name+"玩王者荣耀");
    }
    //发短信
    public void sendMessage(String name) {
        System.out.println("给"+name+"发短信");
    }
}

package study2.demo;
/*
测试手机类
 */
public class TestPhone {
    //main方法是程序的主入口，所有代码的执行都是从这里开始的
    public static void main(String[] args){
        //1.创建对象
        Phone p = new Phone();
        //2.调用成员变量，并打印
        //给成员变量赋值
        p.brand = "华为";
        p.model = "P30";
        p.name = "小黑";
        //打印成员变量的值
        System.out.println("手机品牌是"+p.brand+"型号是"+p.model+"它的主人是"+p.name);
        System.out.println("————————");
//        2.调用成员方法
        p.call("小黑");
        p.playGame("小黑");
        p.sendMessage("小黑");
    }
}

Java中使用变量的规则：

结论：使用变量遵循“就近原则”，如果局部位置有，就使用；没有就去本类的成员位置找，有就使用，没有就报错

局部位置：方法的参数列表或方法体语句（方法内部）

成员位置：类中，方法外

package study2.demo;
//定义一个学生类
public class Student {
//  成员变量
    String name;
    int age;
    public void study() {
//        局部变量
        String name = "小A";
        System.out.println(name+"正在学习中……");
    }
}

package study2.demo;

public class TestStudent {
    public static void main(String[] args) {
//        1.创建对象
        Student stu = new Student();
//        2.给成员变量赋值，并打印结果
        stu.name = "小黑";
        stu.age =  22;
        System.out.println(stu.name);
        System.out.println(stu.age);
        System.out.println("——————————");
//        3.调用成员方法
        stu.study();
    }
}

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

定义位置：

成员变量：类中，方法外

局部变量：方法中，或形式参数

初始化值：

成员变量：有默认初始化值

局部变量：无默认初始化值，必须先赋值在使用

作用范围：

成员变量：在类中

局部变量：在方法中

内存中的位置：

成员变量：推内存

局部变量：栈内存

生命周期：

成员变量：随着对象的创建而存在，随着对象的消失而消失

局部变量：随着方法的调用而存在，随着方法调用完毕而消失

注意事项：

局部变量和成员变量重名时，采用就近原则

封装

基本义：把物体打包装到箱子里，然后封起来

引申义：把一系列功能打包到一台设备里，提供使用这些功能的界面

常见的封装体：汽车、电脑、洗衣机……

封装的好处

提高安全性；提高复用性；将复杂的事情简单化

Java中的方法、类体现了封装

方法：

安全性：调用者不知道方法的具体实现

复用性：方法可以被重复使用

简单化：将繁多的代码以一个方法的方式呈现，仅通过调用方法就可以实现功能；代码维护也变得简单

类：

安全性：调用者不知道类的具体实现

复用性：类的对象可以被重复使用

简单化：类的对象包含了更多的功能，使用起来也方便

private关键字

private的基本概念：私有的，一种访问权限修饰符，用来修饰类的成员

特点：被修饰的成员只能在本类中访问

用法：

private 数据类型 变量名；

private 返回值类型 方法名(参数列表) {}

扩展：public,公共的，访问权限修饰符，用来修饰类、成员变量、成员方法等，被修饰的内容可以在任意类中访问

案例：private修饰成员变量

需求：给Student类的成员变量用private修饰，然后再测试类中正确使用该成员变量

package study2.demo;
//定义一个学生类
public class Student {
//  成员变量
    String name;
    private int age;

//    提供公共的访问方式，分别设置值，获取值
//    设置age的值
    public void setAge(int a) {
//        在这里，对age的值进行限定
//        这里虽然可以对age的值做限定，但是不用做
//        因为从前端传过来的数据本身就是已经效验过的合法的数据
//        if (a >200 || a <=0) {
            非法值
//            age = 1;
//        }else {
            合法值
//            age = a;
//        }
        age = a;
    }
//    获取age的值
    public int getAge() {
        return age;
    }

    public void study() {
//        局部变量
        System.out.println(name+"正在学习中……");
    }
}

package study2.demo;

public class TestStudent {
    public static void main(String[] args) {
//        1.创建学生类对象
        Student stu = new Student();
//设置值
        stu.name = "aaa";
//        若是非法值，则改为默认值
//        stu.setAge(-23);
        stu.setAge(23);
        System.out.println(stu.getAge());
        //        3.调用成员方法
        stu.study();
    }
}

结论：private一般用来修饰成员变量

​ public一般用来修饰方法

this关键字

this的基本概念：这，这个，表示本类对象的引用，本质是一个对象

特点：每一个普通方法都有一个this，谁调用该方法，this就指向谁(代表对象中的成员变量或者方法）

用法：

this.属性名;

this.方法名(参数);

package study2.demo;
//定义一个学生类
public class Student {
//    成员变量
    private int age = 20;
//    设置年龄
//    局部变量改变，对成员变量无影响           可以理解为this在方法内改变成员变量
//    setAge是局部变量
    public void setAge(int age) {
//        若是不加this.的话，则输出的是20而不是30
        this.age = age;
    }
//getAge是成员变量，只有加了this后成员变量的值才等于被赋值后的局部变量
    public int getAge() {
        return age;
    }
//    为了让你更好的理解this的作业，先做一个测试题
    public void show() {
//        局部变量
        int age =10;
        System.out.println(age);
        System.out.println(this.age);
    }
}

package study2.demo;

public class TestStudent {
    public static void main(String[] args) {
//   需求1：调用show()方法
    Student stu = new Student();
    stu.show();
        System.out.println("————————————");
//    需求2：按照格式，优化setAge()中的参数名，并调用
//        设置年龄
        stu.setAge(30);
//        获取年龄

        System.out.println(stu.getAge());
    }
}