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

构造方法的基本概念

构件、构造，也叫构造器，用来帮助创建对象的方法，准确的说，构造方法的作用是初始化对象

谁来创建对象？

new关键字。java中通过new关键字创建对象，并在内存中开辟空间，然后使用构造方法（构造器）完成对象的初始化工作

构造方法的定义

格式

​ 修饰符 构造方法名(参数列表) {

​ //方法体

​ }

要求：

方法名必须与类名相同（包括大小写）；

没有返回值（但是里面可以写return:表示方法的结束）；

没有返回值类型（连void都不能写）。

注意事项：

若未提供任何构造方法，系统会给出默认无参构造；

若已提供任何构造方法，系统不再提供无参构造；

构造方法可以重载

package study2.demo;

public class TestStudent2 {
    public static void main(String[] args) {
//        需求：定义一个姓名叫：张三，年龄为23的学生
//        格式一:通过无参构造实现
        Student2 stu = new Student2();
        stu.setName("张三");
        stu.setAge(23);
        System.out.println(stu.getName());
        System.out.println(stu.getAge());

//        格式二：通过构造方法实现快速初始化
        Student2 stu2 = new Student2("李四",24);
        System.out.println(stu2.getName());
        System.out.println(stu2.getAge());

    }
}

package study2.demo;

public class Student2 {

//    无参构造
    public Student2() {
        return;
    }
//    带参构造
    public Student2(String name,int age) {
        this.name = name;
        this.age = age;
    }
    //    成员变量
    private String name;
    private int 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;
    }
}

标准代码：JavaBean

Java语言编写类的标准规范。符合JavaBean标准的类，必须是具体的、公共的、并且具有无参数的构造方法，提供用来操作成员变量的set和get方法

Java中封装的概念：将一系列相关事物共同的属性和行为提取出来，放到一个类中，隐藏对象的属性和实现细节，仅对外提供公共的访问方式

封装的关键

绝对不能让类中的方法直接其他类的数据（属性），程序仅通过对象的方法与对象的数据进行交互

package study.demo;
/*
    定义一个标准的javabean类
 */
public class Student {
//    成员变量：全部用private修饰
//    姓名
    private String name;
//    年龄
    private int age;

//    构造方法：无参和全参
//    无参
    public Student() {};
//    全参
    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }

//    公共的访问方式：getXxx()\setXxx()
//    设置姓名
    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;
    }
}

package study.demo;

public class TestStudent {
public static void main(String[] args) {
// 需求：通过空参创建对象
Student stu1 = new Student();
stu1.setName(“aa”);
stu1.setAge(20);
System.out.println(stu1.getName());
System.out.println(stu1.getAge());
System.out.println("——————————");
// 需求：通过全参创建对象
Student stu2 = new Student(“bb”,23);
System.out.println(stu2.getName());
System.out.println(stu2.getAge());
}
}