11 面向对象（面向对象的思想；类与对象及其应用；对象的内存图；成员变量和局部变量的区别；匿名对象；封装(private)；this关键字）

qq_44725165

于 2019-10-07 22:58:55 发布

阅读量156

点赞数

分类专栏： Java

本文链接：https://blog.csdn.net/qq_44725165/article/details/102318876

版权

Java 专栏收录该内容

16 篇文章 0 订阅

订阅专栏

面向对象的思想

package org.westos.demo;
public class MyTest {
    public static void main(String[] args) {
        //对象：万物皆对象
        //面向对象：指挥对象帮你做事情

        //现实世界，由万事万物所构成--事物
        //事物---猫      --->属性,行为

        //事物----------------------------> Java中
        // 猫--->属性, 行为（功能）   ----->>>     类 class--->成员属性（成员变量）, 成员功能（成员方法）
        //类，是我们Java中最小单位，体现的是一种封装的思想，封装了属性和功能
        //Java中面向对象的三大特征：封装，继承，多态
    }
}

面向对象思想概述

面向过程思想概述
我们来回想一下，这几天我们完成一个需求的步骤：首先是搞清楚我们要做什么，然后在分析怎么做，最后我们再代码体现。
一步一步去实现，而具体的每一步都需要我们去实现和操作。这些步骤相互调用和协作，完成我们的需求。
在上面的每一个具体步骤中我们都是参与者，并且需要面对具体的每一个步骤和过程，这就是面向过程最直接的体现。
那么什么是面向过程开发呢? 面向过程开发，其实就是面向着具体的每一个步骤和过程，把每一个步骤和过程完成，然后由这些功能方法相互调用，完成需求。
面向过程的代表语言：C语言
面向对象思想概述
当需求单一，或者简单时，我们一步一步去操作没问题，并且效率也挺高。
可随着需求的更改，功能的增多，发现需要面对每一个步骤很麻烦了。这时就开始思索，
能不能把这些步骤和功能在进行封装，封装时根据不同的功能，进行不同的封装，功能类似的封装在一起。
这样结构就清晰了很多。用的时候，找到对应的类就可以了。这就是面向对象的思想。
面向对象思想特点
a:是一种更符合我们思想习惯的思想懒人思想
b:可以将复杂的事情简单化
c:将我们从执行者变成了指挥者角色发生了转换

面向对象思想举例

举例:
洗衣服：换下脏衣服—盛水----浸泡------手搓----漂清—晾干
全自动洗衣机----------- 一键洗衣
面向对象特征
封装(encapsulation)
继承(inheritance)
多态(polymorphism)
面向对象开发
就是不断的创建对象，使用对象，指挥对象做事情。

类与对象及其应用

类与对象概述

我们学习编程是为了什么
我们学习编程语言，就是为了模拟现实世界的事物，实现信息化。比如：去超市买东西的计费系统，去银行办业务的系统。
我们如何描述现实世界事物
举例: 描述学生事物
姓名 , 年龄 , 性别 …
学习 , 吃饭 , 睡觉 …

属性: 就是该事物的描述信息
行为: 就是该事物能够做什么
我们学习编程语言,就是为了模拟现实中的事物,我们学习的Java语言最基本单位是类，所以，我们就应该把事物用一个类来体现。
由此我们就得到了现实中的事物和类的对应关系

		事物				        类
		属性	----------------- 成员变量
		行为	----------------- 成员方法

定义类其实就是定义类的成员(成员变量和成员方法)
a:成员变量和以前定义变量是一样的，只不过位置发生了改变。在类中，方法外。
b:成员方法和以前定义方法是一样的，只不过把static去掉，后面在详细讲解static的作用。
类和对象的概念
a:类：是一组相关的属性和行为的集合
b:对象：是该类事物的具体体现
c:举例：
类------学生
对象------班长就是一个对象
举例 (Person)

//定义一个类：class
package org.westos.demo;

public class Person {  //定义的Person这个类里封装了三个属性和三个功能

    //成员属性，成员变量：定义在类中方法外
    String name="zhangsan";  //名字
    int age;  //年龄   // 没赋值前的默认值都是0
    char sex;  //性别

    //成员功能，成员方法
    public void eat() {
        System.out.println("吃饭");
    }
    public void sleep() {
        System.out.println("睡觉");
    }
    public void playGame() {
        System.out.println("打豆豆");
    }
}

//如何使用定义好的一个类
package org.westos.demo;

import java.util.Scanner;
public class MyTest {
    public static void main(String[] args) {
        // 类：他是一个抽象的概念，他不能直接使用，如果要使用，我们需要对类进行实例化
        //所谓实例化，就是创建该类对象，因为对象才是类的具体表现
        // 怎么创建一个类的对象呢，使用关键字new
        Person person = new Person();
        //该类对象创建成功后，使用该类对象，就可以调用类中的属性和功能
        
        //先给属性赋值
        person.name = "王五";
        person.age = 23;
        person.sex = '男';

        //获取属性的值
        String name = person.name;
        int age = person.age;
        char sex = person.sex;
        System.out.println(name);
        System.out.println(age);
        System.out.println(sex);

        //使用功能
        person.eat();
        person.sleep();
        person.playGame();
    }
}

手机类的定义手机类的使用

定义
属性 ----- 成员变量
行为 ----- 成员方法
使用
文件名问题
——在一个java文件中写两个类：一个基本的类，一个测试类。
——建议：文件名称和测试类名称一致。
如何使用呢?
——创建对象使用。
如何创建对象呢?
——格式：类名对象名 = new 类名();
如何使用成员变量呢?
——格式：对象名.变量名
如何使用成员方法呢?
——格式：对象名.方法名(…)
举例 (Phone)

package org.westos.demo;

public class Phone {

    //成员属性
    String name="小米";
    double price;

    //成员功能
    public void call(String name){
        System.out.println("给"+name+"打电话"); //传参 用name这个参数
    }
    public void sendMsg(String name,String content){
        System.out.println("给" + name + "发短信内容"+content);
    }
}

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {

        Phone phone = new Phone();

        phone.name="魅族";
        phone.price=1000; // 给属性赋值

        System.out.println(phone.name);
        System.out.println(phone.price);

        phone.call("雷总");
        phone.sendMsg("黄老板","国庆阅兵怎么没去？");

        System.out.println("------------------------------");

        Phone phone1 = new Phone();
        phone1.name="华为";
        phone1.price=2000;
        System.out.println(phone1.name);
        System.out.println(phone1.price);
        phone1.call("你好！！！");
        phone1.sendMsg("余大嘴","你好！");
    }
}

对象的内存图

一个对象的内存图

画图演示: 一个对象
在这里插入图片描述

二个对象的内存图

画图演示: 二个不同的对象
在这里插入图片描述

三个引用二个对象的内存图

画图演示: 三个引用，有两个对象的引用指向同一个地址
在这里插入图片描述

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

成员变量局部变量区别

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

//成员变量和局部变量的区别
        
        //成员变量：定义在类中方法外的变量
        //局部变量：定义在方法中的变量，或方法声明上的形参
        
        //成员变量存在堆内存，局部变量存在栈内存
        
        //成员变量：随着对象的创建而产生，随着对象被回收而消失
        //局部变量：随着方法的调用而产生，随着方法的调用完毕而消失
               
        //成员变量：属于对象,也就做实例变量    局部变量：属于方法
        //局部变量没有默认值。成员变量有默认值

注意事项：: 局部变量名称可以和成员变量名称一样，在方法中使用的时候，采用的是就近原则。

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
        Student student = new Student();
        student.show("王五");
    }
}
class Student { 
//在一个java文件中可以定义多个类 但是public只能加给其中一个类 加给有主方法的那个  //不建议并列定义多个类
    String name = "张三";
    public void show(String mingzi) {
        System.out.println(mingzi);//王五  // 取到student.show("王五"); 这个show方法里的 王五  mingzi
        System.out.println(name);//张三 //局部里面没有这个name 就到成员里去找 找到String name = "张三";
    }
}

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
        Student student = new Student();
        student.show("王五");
    }
}
class Student {  
    String name="张三";    
    public void show(String name) {
        //当成员变量和局部变量重名时，那么访问变量的规则就遵从就近原则
        //就近原则：先从局部范围找，找个变量，找到就使用，如果找不到，去成员位置找，找到就成员
         System.out.println(name);//王五   //成员变量name和局部变量name重名 遵从就近原则 先从局部范围找
        System.out.println(name);//王五
    }
}

方法的形式参数是类名的时候如何调用

A:Java中参数传递问题
形式参数
基本类型：形式参数的改变不影响实际参数
引用类型：形式参数的改变直接影响实际参数
B:方法的参数是类名
如果你看到了一个方法的形式参数是一个类类型(引用类型)，这里其实需要的是该类的对象。

package org.westos.demo;

public class MyTest {

    public static void main(String[] args) {
       Teacher teacher = new Teacher();//当你以后看到一个方法的形参，要一个 类 类型(引用类型)。你就传该类的一个对象 
        //这里new一个Teacher的对象   分析程序时始终关注这个new的对象 Teacher
        show(200, teacher); //调用方法show
        int age = teacher.age;
        System.out.println(age);  // 50  //teacher.age = 20 后进行 teacher.test(50)的调用  重新赋值 变成50
    }
    public static void show(int num, Teacher teacher) {
        System.out.println(num);//200
        teacher.age = 20;
        teacher.test(50);//调用方法test  //对age重新赋值 将20变为50
    }
}
class Teacher {
    int age;
    public void test(int n) {
        this.age = n;
        System.out.println(age); //50
    }
}

在这里插入图片描述

匿名对象

匿名对象的概述和应用

什么是匿名对象
就是没有名字的对象
只有创建对象的语句，确没有把对象地址值赋值给某个变量

Person p=new Person; //创建一个普通对象
new Person(); //创建一个匿名对象

匿名对象应用场景
a:调用方法，仅仅只调用一次的时候。
b:匿名对象可以作为实际参数传递

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
        //匿名对象：没有名字的对象
      /*  A a = new A();
        a.show();
        a.show();
        a.show();//同一个对象 把方法调用了3次

        new A().show();
        new A().show();//每一次都调用了new新对象  每new一次都是新对象
        */
        //这个类中的方法，我只想调用一次，我可以使用匿名对象来调用 //new A().show();//每次调用新对象
      
        A a = new A();
        test(a); //new出来 把对象名字a传进去就行
        test(a);

        //匿名对象可以作为参数来传递
        test(new A());//匿名对象  不起名 仅仅是A类型 
    }
    public static void test(A a) {      //test方法 要 A类型 (引用类型)
    //如果一个方法的形参是一个 类 类型(引用类型)，这里其实需要的是该类的对象 需要new出来
        a.show();
    }
}
class A {
    public void show() {
        System.out.println("这是一个show方法");
    }
}

封装(private)

封装的概述

A:封装的引入
通过学生案例，给年龄赋值为负数引出数据问题。
然后通过private解决这个问题。最后说其实这就是封装。
B:封装概述
是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。
C:封装好处
隐藏实现细节，提供公共的访问方式
提高了代码的复用性
提高安全性
D:封装原则
将不需要对外提供的内容都隐藏起来
把属性隐藏，提供公共方法对其访问

举例（Person）

package org.westos.demo;

public class Person {
    //private 私有的，是一个权限修饰符，可以修饰成员变量和成员方法，修饰后，该成员只能在本类中访问
//原本在MyTest.java中，可以通过“对象名.属性名=值”（如p.age=230）这种方式来赋值
//现在Person.java中，将int age变为private int age，另一个类MyTest中p.age=230就无法访问了，age的值只在本类中访问
    private String name;
    private int age;

    //成员变量全部私有 用 get set 让用户可以间接的获得或设置

    //get set 方法的规范  (age--getAge，name--setName:首字母要大写）
    //提供一个公共的赋值的方法
    //get set 方法 必须是公共的 要确保用户在另一个类中能设置这些值
    public void setAge(int nianLing) {
        if (nianLing >= 0 && nianLing <= 100) {
            age = nianLing;
        } else {
            System.out.println("这个年龄的数据不合理");
        }
    }
    public int getAge() {  //用户可以获取age
        return age;
    }
    public void setName(String mingzi) { //用户可以设置name
        name = mingzi;
    }
    public String getName() { //用户可以获取name
        return name;
    }
    private void show() {
        System.out.println(name);
        System.out.println(age);
    }
}

package org.westos.demo;

public class MyTest {
    public static void main(String[] args) {
        //我们通过“对象名.属性名=值”这种赋值方式， 不能验证数据的合理性
        //我们现在想要对赋值的数据进行合理性的验证，需要屏蔽掉“对象名.属性名=值”这种赋值方式
        //怎么来屏蔽掉呢?可以使用一个关键字private 私有的，是一个权限修饰符
        
        Person p = new Person();
        
        //p.name="张三"; //被Person.java中的 private String name屏蔽
        //p.age=230;//被Person.java中的 private int age 屏蔽
        
        //private屏蔽掉直接赋值方式后，可以提供一个间接的赋值方式
        //设置值
        p.setName("张三"); //设置name
        p.setAge(20); //设置age
        
        //获取属性值的方法 //在Person.java中  public int getAge(){return age;}
        int age = p.getAge(); //返回age
        String name = p.getName(); //返回name
        System.out.println(name);
        System.out.println(age);
        
       // p.show();//在Person.java中 是private void show() 只能本类访问 所以这里不能访问
    }
}

举例（Phone）

package org.westos.demo;

public class Phone {
    //私有成员变量
    private String name;
    private double price;

    //提供公共的set get 方法
    public void setName(String mingzi){
        name=mingzi;
    }
    public void setPrice(double jiage){
        price=jiage;
    }
    public String getName(){
        return name;
    }
    public double getPrice(){
        return price;
    }
}

package org.westos.demo;

public class Test {
    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.setName("小米"); //设置
        phone.setPrice(500);

        String name = phone.getName(); //获取
        double price = phone.getPrice();
        System.out.println(name+"===="+price);
    }
}

private关键字的概述和特点

A:private关键字特点
a:是一个权限修饰符
b:可以修饰成员变量和成员方法
c:被其修饰的成员只能在本类中被访问
B:案例演示
private关键字特点

private常见应用

private最常见的应用：
(1):把成员变量用private修饰
(2):提供对应的getXxx()和setXxx()方法

this关键字

this关键字的概述和应用

为什么要有this
当我们的局部变量和成员变量相同的时候,如果我们不使用this关键字,那么会导致一个问题:就是局部变量隐藏了成员变量的问题
this关键字特点
是当前类的对象引用。
简单的记，它就代表当前类的一个对象。谁调用这个方法,那么该方法的内部的this就代表谁
this的应用场景
解决局部变量隐藏成员变量
案例演示
this的应用场景

package org.westos.demo;
public class Phone {
    //私有成员变量
    private String name;
    private double price;

    //提供公共的set get 方法
    public void setName(String mingzi){
        name=mingzi;
    }
    /*public void setName(String name) { //如果这里变成(String name) 那么成员变量和局部变量就都是name重名了
       //就近原则 name不会去找前面private String name中的name
       //而是会去找public void setName(String name)中的name 就相当于自己赋值给自己了
        name = name;
    }*/
    
    /*//如果想区分name的话 可以使用关键字this
     public void setName(String name) { 
        this.name = name; // 变为 this.name 
    }*/
}

举例（Phone）

package org.westos.demo;

public class Phone {
    //私有成员变量
    //this 表示本类的一个引用。你可以理解为本类的一个对象，哪个对象调用这个方法，那么方法中的this就代表这个对象
    private String name;
    private double price;

    //提供公共的set get 方法 //方法中的this 就代表那个调用者，谁调用就代表谁
    public void setName(String name){             
        System.out.println("this代表调用者的地址值"+this);
        this.name=name;
    //this加在方法public void setName(String name){}中，这个方法是phone在调用，所以this就代表这个对象phone
    }
    public void setPrice(double price){
        System.out.println("this代表调用者的地址值" + this);
        this.price=price;
    }
    public String getName(){
        return name;
    }
    public double getPrice(){
        return price;
    }
}

package org.westos.demo;

public class Test {
    public static void main(String[] args) {
        Phone phone = new Phone();
        System.out.println(phone+"调用者的地址值");
        phone.setName("小米");
        phone.setPrice(500);

        String name = phone.getName();
        double price = phone.getPrice();
        System.out.println(name+"===="+price);

        System.out.println("------------------------");
        Phone phone2 = new Phone();//phone2调取的话  this代表phone2
        System.out.println(phone2 + "调用者的地址值");
        phone2.setName("小米");
        phone2.setPrice(500);

        String name2 = phone2.getName();
        double price2 = phone2.getPrice();
        System.out.println(name2 + "====" + price2);
    }
}

//快速生成get  set 方法
package org.westos.demo;
public class Phone {
    private String name;
    private double price;
    private String color;
    //快捷键 "alt+insert" 在弹出窗口中选 getterAndSetter；"ctrl+a" 把name price color三个全选中 
    //只想选两个 就按住ctrl别松 选两个就行   // 也可以自己根据意愿去选择 
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getPrice() {
        return price;
    }
    public void setPrice(double price) {
        
        this.price = price;
    }
    public String getColor() {
        
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
}

qq_44725165

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
11 面向对象（面向对象的思想；类与对象及其应用；对象的内存图；成员变量和局部变量的区别；匿名对象；封装(private)；this关键字）

文章目录面向对象的思想面向对象思想概述面向对象思想举例类与对象及其应用类与对象概述手机类的定义手机类的使用学生类的定义学生类的使用对象的内存图一个对象的内存图二个对象的内存图三个引用二个对象的内存图成员变量和局部变量的区别成员变量局部变量区别方法的形式参数是类名的时候如何调用匿名对象匿名对象的概述和应用封装(private)封装的概述private关键字的概述和特点private常见应用th...
复制链接

扫一扫