Java 面向对象-封装

1.面向对象思想概述

·面向

基本意:面向、朝向

引申意:注重、关注

·对象

世间一切事物

·面向过程思想:

面向过程思想就是把关注点放在一件事或一个活动中涉及到的步骤(也就是过程)上的思想

·面向对象思想:

-面向对象思想就是把关注点放在一件事或一个活动中涉及到的人或事物(也就是对象)上的思想

-特点:更符合人们思考习惯的思想、把复杂的事情简单话、把人们从执行者变成指挥者

-特征:封装、继承、多态

2.类与对象

描述事物从两个方面着手

1.属性

2.行为

java中如何描述一个事物?

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

类的概念

即归类,分类,是一系列具有相同属性和行为的事物的统称,拥有属性和行为

抽象

把一系列相关事物共同的属性和行为提取出来的过程

对象-什么是对象?

某一类事物的某个具体存在

类和对象的关系

类:属性和行为的集合,是一个抽象概念

对象:是该类事物的具体体现,是一个具体存在

3.类的定义和使用

如果定义一个类?

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

事物的属性,在类中叫成员变量

事物的行为,在类中叫成员方法

如果创建一个对象?

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

如何使用一个对象?

对象名.变量名

对象名.方法名()

例子:手机类的定义和使用

1.定义:

类名:Phone

成员变量:

String brand;//品牌

String model;//型号

String name;//名称

成员方法:

call();//打电话

sendMessage();//发短信

playGame();//玩游戏

2.使用:

Phone p = new Phone();

//定义一个手机类
public class Phone {
    //成员变量:定义类中,方法外的变量
    //品牌
    String band;
    //型号
    String model;
    //名称
    String name;
    //成员方法
    //打电话
    public void call(String name){
        System.out.println("给"+name +"打电话" );

    }
    //发短信
    public void sendMessage(String name){
        System.out.println("给"+name +"发短信" );

    }
    //玩游戏
    public void playGame(){
        System.out.println("玩游戏");
    }
}
public class TestPhone {
    //main函数是程序的主入口,所有代码的执行都是从这里开始
    public static void main(String[] args) {
        //1.创建对象
        Phone p = new Phone();

        //2.调用成员变量并打印
        //给成员变量赋值
        p.band = "苹果";
        p.model = "x";
        p.name = "a同学";

        //打印成员变量的值
        System.out.println(p.band);
        System.out.println(p.model);
        System.out.println(p.name);

        //3.调用成员方法
        System.out.println("==========");
        p.call("b同学");
        p.sendMessage("c同学");
        p.playGame();

    }
}

JAVA中使用变量的规则

使用变量遵循就近原则,如果局部位置由,就使用

没有就去本类成员位置找,有就使用,没有就报错

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

1.定义位置

成员变量:类中,方法外

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

2.初始化值

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

局部变量:无默认初始化值,必须先赋值再使用

3.作用范围:

成员变量:在类中

局部变量:在方法中

4.在内存中位置:

成员变量:堆内存中

局部变量:栈内存中

5.生命周期

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

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

注意事项:

局部变量和成员表变量重名时,采取就近原则

4.封装概述

什么是封装?

把一系列能打包到一台设备里,提供使用给这些功能的界面

封装的好处

-提高安全性

-提高复用性

-将复杂的事情简单化

java中的封装体

1.方法

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

复用性:方法可以重复使用

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

2.类

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

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

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

5.private关键字

private的基本概念

私有的,一种访问权限修饰符,用来修饰类的成员

特点:别修饰的成员只能在本类中访问

用法:

private 数据类型  变量名

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

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

例子:private修饰成员变量

需求:给student类的变量用private修饰,然后再测试类中正确使用该成员变量

public class Student {
    //成员变量
    //姓名
    private String name;
    //年龄
    private int age;

    //成员方法
    //学习
    public void study(){

        System.out.println(name + "在学习");
    }

    //提供公共访问方式,分别设置值,获取值
    //设置姓名
    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 class TestStudent {
    public static void main(String[] args) {
        Student s = new Student();
        //调用setName成员方法来设置成员变量name
        s.SetName("张三");
        //调用setAge成员方法来设置成员变量age
        s.setAge(15);
        //调用getName和getAge方法来获取姓名和年龄
        System.out.println("姓名:"+s.getName()+"年龄:"+s.getAge());
    }
}

运行结果:

6.this关键字

表示本类对象的引用,本质是一个对象

特点

每一个普通方法都有一个this,谁调用该方法就指向谁

用法

this.属性名

7.标准代码:JavaBean

构造方法的基本概念

构建、创造,也叫构造器,准确的说,构造方法的作用是初始化对象

谁来创建对象?

new关键字,Java中通过new关键字创造对象,并在内存中开辟空间,然后使用构造方法(构造器)完成对象的初始化工作

构造方法的定义

格式

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

//方法体

}

注意事项:

1.方法名必须与类名相同(包括大小写)

2.没有返回值(但是里面可以写return)

3.没有返回类型(也没有void)

4.若未提供任何构造方法,系统会给出默认无参构造

5.若已提供任何构造方法,系统不再提供无参构造

6.构造方法可以重载

标准代码:JavaBean

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

Java中封装的概念

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

封装的关键

绝对不能让类中的方法直接访问其他类的数据(属性),程序仅通过对象的方法与对象的数据进行交互

例子:

//定义一个标准的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 this.name;
    }
    //设置年龄

    public void setAge(int age) {
        this.age = age;
    }
    //获取年龄
    public int getAge() {
        return age;
    }
}
public class TestStudent {
    public static void main(String[] args) {
        Student stu = new Student();
        stu.setName("张三");
        stu.setAge(12);
        System.out.println("姓名:"+stu.getName()+"年龄:"+stu.getAge());

        System.out.println("===================");
        Student stu2 = new Student("李四",15);
        System.out.println("姓名:"+stu2.getName()+"年龄:"+stu2.getAge());

    }
}

运行结果:

原文地址:https://www.cnblogs.com/tlidx/p/11449543.html

时间: 2024-10-12 18:36:37

Java 面向对象-封装的相关文章

Java面向对象㈠ -- 封装

Java的面向对象有三大特征:封装.继承.多态.这里主要对封装进行讲解. 封装可以理解为隐藏一个类的成员变量和成员函数,只对外提供需要提供的成员函数. Java的封装主要通过访问权限控制符:private,默认,protected,public来实现.(这四个权限访问控制符的区别网上有很多,建议读者自行搜索学习,切记要亲自练习一下!)最明显的实现就是把类的成员变量私有(private),只能通过类的成员函数来进行访问,并且此时的成员函数公有(public).这就是著名的setter/getter

Java面向对象--封装

封装:是把过程和数据包围起来,对数据的访问只能通过已定义的接口.面向对象计算始于这个基本概念,即现实世界可以被描绘成一系列完全自治.封装的对象,这些对象通过一个受保护的接口访问其他对象.封装是一种信息隐藏技术,在java中通过关键字private实现封装.(字段私有化) 什么是封装?封装把对象的所有组成部分组合在一起,封装定义程序如何引用对象的数据,封装实际上使用方法将类的数据隐藏起来,控制用户对类的修改和访问数据的程度. 封装的例子: public class Man { //对属性的封装,一

Java面向对象----封装概念

封装 信息隐藏,隐藏对象的细节 访问修饰符 public private protected 默认 属性封装的实现 方法封装的目的(隐藏方法实现细节) package com.tanlei.newer; public class TeacherDemo { public static void main(String[] args) { teacher t=new teacher(); //t.name("zhangs"); t.setName("zhangs");

Java 面向对象-封装,继承

一:封装 特点:隐藏了实现细节,对外提供可以访问的方式. 关键字 private 将属性和方法私有化. 实现过程: 在 SetColor() 方法中可以限制调用者的输入.提高类的安全性. 二.this关键字 可以区分成员变量和局部变量 用this.变量 获取/设置 的是成员变量 注意:谁调用 this 就指向那个对象 三:继承(extends) 注意:继承只能是单继承(子类只能继承一个父类),但是父类可以被多个子类继承 格式:class 子类 extends 父类 {} 子类可以访问父类的属性和

JAVA面向对象封装(无参构造、有参构造、失血模型、重写toString)方法

//定义一个学生类public class Student {    //成员变量    private String name;    private int age;    private String address;    //无参构造方法    public Student() {        super();    }    //有参构造方法    public Student(String name, int age, String address) {        super

Java面向对象的封装

封装是Java面向对象的三大特性之一,通常我们是通过包管理机制同时对类进行封装,隐藏其内部实现细节,通常开发中不允许直接操作类中的成员属性,所以属性一般设置为私有权限private,类中一般会给出一些公共方法来让使用者通过特定方法读取或者操作里面的数据,避免误操作从而保证了数据的安全. 封装步骤一般分为3步,第一步首先修改属性的可见性,即将其设置为private:第二步创建getter/setter方法,用于获取/设置属性值,就是用来读写属性,eclipse中也提供了直接生成变量操作方法的菜单,

(1) 深入理解Java面向对象三大特性 封装 继承 多态

转眼已经工作快6年了,最开始做了2年J2EE:然后整了2年的数据仓库,主要是Cognos的报表开发:现在从事4G LTE核心网的开发,用的语言任然是Java,但写代码的机会不多,基本都是看代码找BUG,偶尔做点new feature也是在比较成熟的框架上复制.粘贴.修改,大部分时间还是在理解业务,钱多.事少.离家近,当时来这家公司图的是后面2点,2年过去了,英文水平有所提升,对敏捷开放也有一定的了解,但技术方面明显退步了或者说没有进步吧,本来以前也不怎么好,因为工作上用不到,自己也没怎么学习,所

黑马程序猿——JAVA面向对象的特性:封装,继承,多态

                                       - ----------android培训.java培训.java学习型技术博客.期待与您交流!------------  一.java面向对象的特性.封装.继承.多态         封装 封装是对象和类概念的主要特性. 封装.也就是把客观事物封装成抽象的类.而且类能够把自己的数据和方法仅仅让可信的类或者对象操作,对不可信的进行信息隐藏. 继承 面向对象编程 (OOP) 语言的一个主要功能就是"继承".继承

Atitit usbQb212 oo 面向对象封装的标准化与规范解决方案java c# php js

1.1. 封装性是面象对象编程中的三大特性之一  三个基本的特性:封装.继承与多态1 1.2. 魔术方法 预定义方法2 1.3. 魔术常量(Magic constants) 预定义变量2 1.4. 适用领域 js php java c#2 1.5. 构造函数 __construct( ) vs xxxCls()3 1.6. 析构函数名称必须是__destruct( )  finally()3 1.7. 私有属性 与工友属性3 1.8. $this指针3 1.9. __autoload() 类自动