java基础学习笔记第六天

最新推荐文章于 2024-10-12 22:35:37 发布

Daniel_zbc1024

最新推荐文章于 2024-10-12 22:35:37 发布

阅读量115

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qq_38067916/article/details/107413634

版权

java基础学习笔记第六天

第1章面向对象概述
第2章对象的内存图
第3章 private、this关键字和封装
第4章面向对象之构造方法

第1章面向对象概述

1.1 面向对象思想

1.我们回想一下，前面我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后在分析怎么做，最后我们再代码体现。一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。
2.在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。
3.那么什么是面向过程开发呢? 面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
4.面向过程的代表语言：C语言
5.当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了，这时就开始思索，能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的用一个类封装在一起，这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。

1.1.1 面向过程思想与面向对象思想

（1）什么是面向过程？
面向过程，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
例如:吃煎饼果子利用面向过程的思想:
1.学习摊煎饼的技术
2.买材料鸡蛋,油,葱等等
3.开始摊
4.吃
5.收拾
（2）什么是面向对象？
面向对象思想就是不断的创建对象，使用对象，指挥对象做事情。（如果有对象，直接用对象，对我们直接提供服务）
例如:吃煎饼果子利用面向对象的思想

找会摊煎饼的大妈(创建一个摊煎饼大妈的对象)
调用其摊煎饼的技能(功能),传递进去钱参数
返回给我们一个煎饼
吃

1.1.2 面向过程特点与面向对象特点

1.面向过程：
强调的是过程，所有事情都需要自己完成
2.面向对象:
是一种更符合我们思想习惯的思想(懒人思想，我把事情自己不做，交给别人去做)
可以将复杂的事情简单化（对使用者来说简单了，对象里面还是很复杂的）
将我们从执行者变成了指挥者角色发生了转换

1.1.2.1 案例代码一

package day06;

/*
* 面向对象：基于面向过程的编程思想
*
*  面向过程：强调的是每一个功能的步骤
*  面向对象：强调的是对象，然后由对象去调用功能
*
* 面向对象的思想特点：
*  1.符合我们的思考方式
*  2.可以将复杂的事情简单化
*  3.让我们由执行者变成了指挥者
*  举例：洗衣服
* 面向过程：把衣服脱下来--找一个盆--放水--放洗衣粉--浸泡10分钟--揉一揉--清洗衣服--拧干--晾起来
* 面向对象：把衣服脱下来--打开全自动洗衣机--放入衣服--按钮--晾起来
*
*
* */

public class Demo01 {

}

1.2 类与对象概述

1.我们学习编程是为了什么?

为了把我们日常生活中实物用学习语言描述出来
2.我们如何描述现实世界事物?
属性就是该事物的描述信息(事物身上的名词)
行为就是该事物能够做什么(事物身上的动词)
3.Java中最基本的单位是类,Java中用class描述事物也是如此
成员变量就是事物的属性
成员方法就是事物的行为
4.定义类其实就是定义类的成员(成员变量和成员方法)
a:成员变量和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
b:成员方法和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
5.类和对象的概念
a:类：是一组相关的属性和行为的集合（我们班所有的同学都具备相同的属性和行为，比如：姓名，年龄，学习，这样就把所有的学生成为学生类）
b:对象：是该类事物的具体体现（说某个同学时，他都具备自己特有的属性和行为）
c:举例：
类学生
对象具体的某个学生就是一个对象
比如：车是一个类，具体的开的奔驰、宝马，就是对

1.2.1 案例代码二

package day06;
/*
 * 我们学习编程语言，其实就是为了把现实世界的事物模拟出来，实现信息化。
 *
 * 我们是如何表示现实世界的事物的呢?
 * 		A:属性	就是事物的描述信息
 * 		B:行为	就是事物能够做什么
 * 		举例：
 * 			学生
 *
 * Java语言最基本的组成单位是类，所以，在后面的学习过程中，我们是通过类来体现事物的。
 *
 * 类：是一组相关的属性和行为的集合
 * 对象：就是该类事物的具体体现
 * 		举例：
 * 			类		学生
 * 			对象	张三
 */

public class Demo02 {
}

1.3 类与对象案例:

1.3.1 学生类的定义

1.3.1.1 案例代码三

package day06;
/*
 * 类;用来描述现实世界的事物的
 * 事物：
 *    属性
 *    行为
 * 类如何与事物进行对应的呢
 *   类
 *   成员变量
 *   成员方法
 *
 * 成员变量：和我们之前学习的变量的定义是一样的，有两个小区别
 *        位置不同：方法外，类中
 *        初始化值：成员变量不需要初始化值也可以使用，因为它有默认值
 * 成员方法：和我们之前定义的方法一样，但有一个小区别
 *          去掉了修饰符中的static关键字
 *
 * 需求:定义一个学生类
 *
 * 学生事物：
 *        属性：姓名，年龄
 *        行为：学习，吃饭
 *
 * 学生类：
 *     成员变量：姓名，年龄
 *     成员方法：学习，吃饭
 *
 *
 *
 *
 * */
public class Student {
    //成员变量
    //姓名
    String name;
    //年龄
    int age;


    //成员方法
    //学习的方法
    public void study(){
        System.out.println("我要成为编程高手");
    }

    //吃饭的方法
    public void eat(){
        System.out.println("我要吃饭！！");
    }
}

1.3.2 学生类的使用

1.3.2.1 案例代码四

package day06;

/*
* 类的是使用：
*         使用一个类就是使用该类的一个成员（成员方法和成员变量）
*         而我们要想使用类，就必须拥有该类的对象
*        首先，我们需要创建一个对象
*        我们如何创建对象呢？
*        格式： 类名 对象名 = new 类名();
*        对象该如何访问成员呢
*            成员变量
*                 对象名.成员变量
*            成员方法
*                 对象名.成员方法()
*
*/

public class StudentTest {
    public static void main(String[] args) {
        //创建一个对象      格式：类名 对象名 = new 类名();
        Student s = new Student();
        //System.out.println("s+" + s); s+day06.Student@4554617c

        //使用成员变量
        System.out.println("s:" + s.name);//null   引用数据类型的默认值是null，因为s是new出来的，所以在堆内存
        System.out.println("s:" + s.age);//0       int类型默认值是0
        System.out.println("--------------");

        //给成员变量赋值
        s.name = "daniel";
        s.age = 23;

        //再次输出
        System.out.println("s:" + s.name);//  daniel
        System.out.println("s:" + s.age);//  23
        System.out.println("--------------");

        //调用成员方法
        s.study();
        s.eat();

    }
}

1.3.3 手机类案例

1.3.3.1 案例代码五

package day06;
/*
* 手机类：
*      成员变量:品牌，颜色，价格
*      成员方法：打电话，发短信
*
* */
public class Phone {
    //手机类
    String brand;

    int price;

    String color;


    //打电话
    public void callPhone(String name){

        System.out.println("给"+ name + "打电话");
    }

    //发短信
    public void sendMessage(String name){

        System.out.println("给"+ name + "发短信");
    }
}


package day06;
/*
* 手机类的测试类
* */
public class PhoneTest {
    public static void main(String[] args) {
        //创建一个手机类
        Phone p = new Phone();


        //输出成员变量赋值
        System.out.println("品牌："+ p.brand);
        System.out.println("价格："+ p.price);
        System.out.println("颜色："+ p.color);
        System.out.println("---------------");

        //给成员变量赋值
        p.brand = "华为";
        p.price = 2345;
        p.color = "黑色";


        //再次输出成员变量
        System.out.println("品牌："+ p.brand);
        System.out.println("价格："+ p.price);
        System.out.println("颜色："+ p.color);
        //调用成员方法
        p.callPhone("daniel");
        p.sendMessage("lucy");
    }
}

第2章对象的内存图

2.1 一个对象的内存图

2.1.1 案例代码六

package day06;
/*
 * 手机类：
 * 		成员变量：品牌，价格，颜色...
 * 		成员方法：打电话，发短信...
 */
public class Phone {
	//品牌
	String brand;
	//价格
	int price;
	//颜色
	String color;
	
	//打电话
	public void call(String name) {
		System.out.println("给"+name+"打电话");
	}
	
	//发短信
	public void sendMessage(String name) {
		System.out.println("给"+name+"发短信");
	}
}


package day06;
/*
 * 手机测试类
 */
public class PhoneTest {
	public static void main(String[] args) {
		Phone p = new Phone();
		
		System.out.println(p.brand+"---"+p.price+"---"+p.color);
		
		p.brand = "huawei";
		p.price = 2999;
		p.color = "褐色";
		
		System.out.println(p.brand+"---"+p.price+"---"+p.color);
		
		p.call("zbc");
		p.sendMessage("zbc");
	}
}

2.1.2 一个对象的内存图图解

2.2 两个对象的内存图(共用方法区)

2.2.1 案例代码七

package day06;
/*
 * 手机类的测试类
 */
public class PhoneDemo2 {
	public static void main(String[] args) {
		Phone p = new Phone();
		p.brand = "红米5s";
		p.price = 2999;
		p.color = "白色";
		System.out.println(p.brand+"---"+p.price+"---"+p.color);
		p.call("zbc");
		p.sendMessage();
		
		Phone p2 = new Phone();
		p2.brand = "IPhoneXS";
		p2.price = 9999;
		p2.color = "土豪金";
		System.out.println(p2.brand+"---"+p2.price+"---"+p2.color);
		p2.call("xyz");
		p2.sendMessage();

2.2.2 两个对象的内存图(共用方法区)图解

2.3 两个对象的内存图(两个引用指向同一个堆内存)

2.3.1 案例代码八

package day06;
/*
 * 手机类的测试类
 */
public class PhoneDemo3 {
	public static void main(String[] args) {
		Phone p = new Phone();
		p.brand = "OPPO";
		p.price = 2999;
		p.color = "白色";
		System.out.println(p.brand+"---"+p.price+"---"+p.color);
		
		Phone p2 = p;
		p2.brand = "魅族";
		p2.price = 1999;
		p2.color = "蓝色";
		System.out.println(p.brand+"---"+p.price+"---"+p.color);
		System.out.println(p2.brand+"---"+p2.price+"---"+p2.color);
	}
}

2.3.2 两个对象的内存图(两个引用指向同一个堆内存)图解

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

2.4.1 案例代码九

package day06;
/*
*  成员变量与局部变量的区别
*              1.在类的位置不同
*              成员变量：在类中，方法外
*              局部变量：在方法中或者方法的声明上（形式参数）
*              2.在内存中的位置不同
*              成员变量：在堆内存
*              局部变量：在栈内存
*              3.声明周期不同
*              成员变量：随着对象的创建而存在，随着对象的小事而消失
*              局部变量：随着方法的调用而存在，随着方法的调用完毕而消失
*              4.初始化值不同
*              成员变量:有默认值
*              局部变量：没有默认值，必须先定义，赋值，然后使用
*
*
* */

public class VariableTest {

        int x;

        public void show() {
        int y = 10;
        System.out.println(x);
        System.out.println(y);
    }


}

第3章 private、this关键字和封装

3.1 private关键字的概述和特点

3.1.1 private关键字

1.private关键字：
a:是一个权限修饰符。
b:可以修饰成员(成员变量和成员方法)
c:被private修饰的成员只在本类中才能访问。

3.1.1.1 案例代码十

package myPrivate;

/*
* 直接使用对象名访问成员变量，会存在数据安全问题
* 这个时候我们就思考能不能让外界不要直接访问成员变量
* 如何去实现？
*     用private关键字
* private
*     是一个修饰符
*     可以修饰成员变量，也可以修饰成员方法
*     被private修饰的成员只能在本类中被访问
*针对被private修饰的成员变量，我们会相应的输出getXxx()和setXxx()
* 用于设置和获取成员变量的值，方法用public 修饰
*
*
* */

public class Student {
    String name;
    //int age;
    private  int age;

    public void setAge(int a){
        if(a<0||a>100){
            System.out.println("你给出的年龄有误！");
        }else {
            age = a;
        }
    }

    public int getAge(){
        return age;
    }

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


package myPrivate;

/*
* 学生类的测试类
* */

public class StudentTest {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        s.show();

        //给成员变量赋值
        s.name = "daniel";
        //s.age = 23;
        //s.age = -23;


        s.setAge(-30);
        s.show();
    }
}

3.2 private修饰后的标准类代码

3.2.1.1 案例代码十一

package myPrivate01;

/*学生类*/

public class Student {

    private String name;
    private int age;

    public void setName(String n){
     name = n;
    }

    public String getName(){
        
        return name;
    }


    public void setAge(int a){
        
        age = a;
    }

    public int getAge(){
        
        return age;
    }
}

3.3 封装的概述和好处

1:封装概述
是面向对象三大特征之一
是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。就像刚才说的年龄。
2:封装原则：
将不需要对外提供的内容都隐藏起来。
把属性隐藏，提供公共方法对其访问。
成员变量private，提供对应的getXxx()/setXxx()方法
3:好处：
通过方法来控制成员变量的操作，提高了代码的安全性
把代码用方法进行封装，提高了代码的复用性

3.4 this关键字的概述和使用

3.4.1 this关键字由来和使用

A:this:代表所在类的对象引用
方法被哪个对象调用，this就代表那个对象
B:什么时候使用this呢
局部变量和成员变量重名

3.4.1.1 案例代码十二

package myThis;

/*学生类
*
* 如果局部变量名称与成员变量名称一致的话，在方法中使用采用的是就近原则
*
* 我们有没有办法把局部变量的name赋值给成员变量的name呢？
*
* 有什么办法呢？
*       用this关键字
*
* this:代表所在类的对象引用
*      方法被哪个对象调用,this就代表谁
*
* 使用场景：用于解决成员变量被隐藏你给的问题
*
* */

public class Student {
    private String name;
    private int age;

    public void setName(String n){
        //name = name;
        this.name = name;
    }
    public String getName(){

        return name;
    }

    public void setAge(int a ){
        //age = age;
        this.age = age;
    }

    public int getAge()
    {
        return age;
    }
}
package myPrivate01;
/*
* 学生类的测试类
*
* */
public class StudentTest {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        System.out.println(s.getName()+"***"+s.getAge());

        s.setName("daniel");
        s.setAge(23);
        System.out.println(s.getName()+"***"+s.getAge());

    }
}

第4章面向对象之构造方法

4.1 构造方法的概述和使用

4.1.1 构造方法作用概述

给对象的数据进行初始化

4.1.2 构造方法格式

方法名与类名相同
没有返回值类型，连void都没有
没有具体的返回值

4.1.3 案例代码十三

package myConstructor;
/*
 * 构造方法：
 * 		给对象的数据进行初始化
 * 
 * 格式：
 * 		方法名和类名相同
 * 		没有返回值类型，连void都不能写
 * 		没有具体的返回值
 *
 */
public class Student {	
	public Student() {
		System.out.println("这是构造方法");
	}
}

package myConstructor;

public class StudentDemo {
	public static void main(String[] args) {
		//如何调用构造方法呢?
		//通过new关键字调用
		//格式：类名 对象名 = new 构造方法(...);
		Student s = new Student();
	}
}

4.2 构造方法的注意事项

如果你不提供构造方法，系统会给出默认构造方法
如果你提供了构造方法，系统将不再提供
构造方法也是可以重载的,重载条件和普通方法相同

4.2.1 案例代码十三

package myConstructor;

/*构造方法：用于给对象的数据进行初始化
*
*格式：
*    方法名与类名相同
*    没用返回值类型，连void都不能写
*    没有具体的返回值
*构造方法的注意事项：
*    1.如果我们没有给出构造方法，系统将给出一个默认的无参数构造方法供我们使用
*    2.如果我们给出了构造方法，系统将不再提供默认的构造方法供我们使用
*    3.构造方法也是可以重载的
* 给成员变量赋值的方式：
* 		A:通过setXxx()
* 		B:通过构造方法

* */

public class Student {
    private String name;
    private int age;


//    public Student(){
//        System.out.println("这是构造方法！");
//    }

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

}

package myConstructor;

/*测试类*/

public class StudentTest {
    public static void main(String[] args) {
        //如何调用构造方法呢？
        //通过new关键字就可以
        //格式 类名 对象名 = new 构造方法名(...)
        Student s = new Student();
        s.show();


        //public Student(String name)
        Student s2 = new Student("daniel");
        s2.show();

        //public Student(int age)
        Student s3 = new Student(23);
        s3.show();

        //public Student(String name,int age)
        Student s4 = new Student("daniel",23);
        s4.show();
    }
}

4.3 标准的类代码和测试

类:
a:成员变量
b:构造方法
无参构造方法
带参构造方法
c:成员方法
getXxx()
setXxx()
给成员变量赋值的方式
a:无参构造方法+setXxx()
b:带参构造方法

4.3.1 案例代码十四

package myConstructor01;

/*标准类*/

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

/*测试类*/

public class StudentTest {
    public static void main(String[] args) {
        //无参构造方法+setXxx()
        Student s = new Student();
        s.setName("daniel");
        s.setAge(23);
        System.out.println(s.getName()+"---"+s.getAge());

        //带参构造方法
        Student s1 = new Student("daniel",23);
        System.out.println(s1.getName()+"---"+s1.getAge());
    }
}