java基础知识---封装！！！

最新推荐文章于 2024-07-10 21:37:49 发布
最新推荐文章于 2024-07-10 21:37:49 发布
阅读量114 收藏
点赞数
分类专栏： Java基础 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/James____Gosling/article/details/118929943
版权

1、 封装

封装概述： 隐藏对象的属性和实现细节，仅对外提供公共的访问方式。

package org.wdzl.unit02;

public class Student {
    String name;
    private int age;
    public void setAge(int age1){
        if (age1 > 0 ){
            age=age1;
        }else {
            System.out.println("你输入的信息有误！！");
        }
    }
    //显示信息
    public void showInfo(){
        System.out.println("name:"+name);
        System.out.println("age:"+age);
    }

}


package org.wdzl.unit02;

public class StudentDemo {
    public static void main(String[] args) {
        Student student = new Student();
        student.name="唐某";
        //student.age = 18;
        student.setAge(18);
        //System.out.println("name"+ student.name);
        //System.out.println("age"+student.age);
        student.showInfo();
        System.out.println("-------------");
        student.name="张三";
        student.setAge(20);
        //System.out.println("name:"+ student.name);
        //System.out.println("age:"+student.age);
        student.showInfo();
    }
}

**封装优点：**安全性高，独立性高，复用性高
封装原则：
1、将不需要用户访问的内用隐藏起来。
2、将属性进行隐藏，提供公共的访问方式。

2、private关键字

！它是一个权限修饰符
！它可以修饰成员变量和成员方法
！被它修饰的变量和方法只能在本类中被访问。

3、封装和private的应用：

1、将成员变量私有化
2、提供对应的getXxx()和setXxx()方法

package org.wdzl.unit02;

/**
 * 标准学生类：
 *    1、私有成员变量
 *    2、提供getXxx()和setXxx()方法
 */
public class Student3 {
    //成员变量
    private String name;
    private int age;

    //name的get，set方法

    //get方法
    public String getName(){
        return name;
    }
    //set方法
    public void setName(String n){
        name = n;
    }

    //age的get，set方法

    //get方法
    public int getAge(){
        return age;
    }
    //set方法
    public void setAge(int a){
        age = a;
    }
}


package org.wdzl.unit02;

/**
 * 学生标准类测试案例
 */
public class Student3Demo {
    public static void main(String[] args) {
        //创建对象
        Student3 student3 = new Student3();
        //设置属性值
        student3.setAge(18);
        student3.setName("唐某人");
        //获取属性值
        System.out.println(student3.getAge());
        System.out.println(student3.getName());
    }
}

4、this关键字

问题：

package org.wdzl.unit02;

/**
 * 学生标准类测试案例
 */
public class Student4 {
    //成员变量
    private String name;
    private int age;

    //name的get，set方法

    //get方法
    public String getName(){
        return name;
    }
    //set方法
    public void setName(String name){
        name = name;
    }

    //age的get，set方法

    //get方法
    public int getAge(){
        return age;
    }
    //set方法
    public void setAge(int age){
        age = age;
    }
}
class Student4Demo {
    public static void main(String[] args) {
        //创建对象
        Student4 student4 = new Student4();
        //设置属性值
        student4.setAge(18);
        student4.setName("唐某人");
        //获取属性值
        System.out.println(student4.getAge());
        System.out.println(student4.getName());
    }
}

此程序运行的结果是：
在这里插入图片描述
解释：
因为在set方法中，name = name;此时由于成员变量和局部变量同名，按照就近原则来处理，public void setName(String name){ name = name; }此时两个name就都是代表着局部变量，所以就是将局部变量赋值给局部变量，而成员变量并未发生改变。
this关键字概述：
1、表示所在类的对象引用，简单来说，就是当前类的对象。
2、它的作用是解决局部变量隐藏成员变量的问题。
3、那个类调用该方法，this就表示那个类。
4、谁调用该方法，该方法内部的this就代表谁。
代码演示：

package org.wdzl.unit02;

/**
 * 学生标准类测试案例
 */
public class Student4 {
    //成员变量
    private String name;
    private int age;

    //name的get，set方法

    //get方法
    public String getName(){
        return name;
    }
    //set方法
    public void setName(String name){
        //方式1
//        Student4 student4 = new Student4();
//        student4.name = name;
        //方式2：
        this.name = name;//this表示当前类的对象
    }

    //age的get，set方法

    //get方法
    public int getAge(){
        return age;
    }
    //set方法
    public void setAge(int age){
        this.age = age;
    }
}
class Student4Demo {
    public static void main(String[] args) {
        //创建对象
        Student4 student4 = new Student4();
        //设置属性值
        student4.setAge(18);
        student4.setName("唐某人");
        //获取属性值
        System.out.println(student4.getAge());
        System.out.println(student4.getName());
    }
}

5、构造方法

概述： 用来创建类的对象，并对类的对象的属性进行初始化。
格式： 1、没有任何返回值，连void都没有。
2、方法名和类名相同。
注意事项：
1、如果我们没有给出构造方法，系统会自动提供一个默认的无参构造方法。
2、如果我们给出了构造方法，系统则不会在提供默认的无参构造方法，推荐大家每次定义类的时候，手动给出无参构造方法。
扩展： 成员变量的赋值有两种方式，1、set方法，2、构造方法赋值。
类的组成：
成员变量
成员方法
a、根据返回值类型：
1、void类型
2、有明确返回值类型（return）
b、根据参数：
1、有参方法
2、无参方法
构造方法

package org.wdzl.unit02;

public class PhoneDemo {
    public static void main(String[] args) {
       Phone phone = new Phone();
       phone.PinPai="华为";
       phone.XingHao="P30";
       phone.setPrice(1999);
       phone.showInfo();
        System.out.println("--------------");
       Phone phone1 = new Phone("VIVO","不知道",599);
       phone1.showInfo();
    }
}

class Phone{

    String PinPai;
    String XingHao;
    private int price;
    public Phone(){}
    public Phone(String PinPai,String XingHao,int price){
        this.PinPai =  PinPai;
        this.XingHao = XingHao;
        this.price = price;
    }
    public void setPrice(int price){
        this.price = price;
    }
    public int getPrice(){
        return price;
    }
    public void showInfo(){
        System.out.println("PinPai:"+PinPai);
        System.out.println("Xinghao:"+XingHao);
        System.out.println("price:"+price);
    }
}

6、成员变量的注意实现

1、当变量为类的描述信息，我们才将它定义为成员变量。
2、变量到底是定义为成员变量好还是局部变量好呢？
变量的定义范围越小越好，因为节省系统资源，能够及时的被垃圾回收机器及时回收。

7、static关键字

概述： 针对对象中有共同属性的这种情况，Java提供了一个关键字来解决这个问题：static
特点： 1、随着类的加载而加载。
2、先于对象存在。
3、被类的所有对象共享（判断是否使用static关键字的一个依据）。

package org.wdzl.unit02;

/**
 * 针对人的一个类
 *     在测试案例中我们发现所有对象都有一个属性都是相同的，
 *     这样的话会造成系统资源不必要的浪费，可不可以使用其他方法来解决这个问题呢？
 *
 *     针对对象中，有共同属性的这种情况，Java提供了一个关键字来解决这个问题，static
 */
public class PersonDemo {
    public static void main(String[] args) {
        Person person = new Person("唐某人",18,"中国");
        person.showInfo();
        System.out.println("----------");
        Person person1 = new Person("赵某人",10);
        person1.showInfo();
        System.out.println("----------");
        Person person2 = new Person("去某人",16);
        person2.showInfo();
        System.out.println("----------");

        person.setCountry("巴铁");
        person1.showInfo();
        person2.showInfo();
    }
}
class Person{
    private String name;
    private int age;
    private static String country;
    public Person(){}
    public Person(String name){
        this.name = name;
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public Person(String name,int age,String country){
        this.name = name;
        this.age = age;
        this.country = country;
    }
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name = name;
    }
    public String getCountry(String country){
        return country;
    }
    public void setCountry(String country){
        this.country = country;
    }

    //显示信息的方法
    public void  showInfo(){
        System.out.println("name:"+name);
        System.out.println("age:"+age);
        System.out.println("country:"+country);
    }
}

在这里插入图片描述
可以通过类名去调用：

package org.wdzl.unit02;

public class StaticDemo {
    public static void main(String[] args) {
        //调用非静态变量
        Demo1 demo1 = new Demo1();
        System.out.println(demo1.num);
        //调用静态的变量
        System.out.println(Demo1.num2);
        System.out.println(demo1.num2);
    }
}
class Demo1{
    //非静态的变量
    int num = 99;
    //静态的变量
    static int num2 = 199;
}

static的内存图解：
在这里插入图片描述
static注意事项：
1、静态方法中不能使用this关键字
2、静态的方法只能调用静态的方法和静态的变量。

package org.wdzl.unit02;

/**
 * static关键字使用注意事项：
 *     1、在静态方法中，this关键字不能使用
 *        分析：静态方法是随着类的加载而加载，它是先于对象而创建的，而this表示的是当前类的对象，它是随
 *             对象产生而产生的，
 *     2、静态的方法只能访问静态的变量和静态的方法,
 *        静态方法：静态的变量和静态的方法
 *        非静态方法：都可以访问
 */
public class StaticDemo2 {
    public static void main(String[] args) {
        Demo2 demo2 = new Demo2();
        demo2.function();
        demo2.method();
    }
}
class Demo2{
    private int num;
    private static int num1;

    public void function(){
        System.out.println(num);//隐式的表示访问的是成员变量
        System.out.println(this.num);//明确的表示访问的是成员变量
        method2();
        method();
    }
    public static void method(){
//        System.out.println(num);//爆红
        System.out.println(num1);
        method2();
//        function();//爆红
    }
    public static void method2(){
        System.out.println("method2");
    }
}

面试题：概述静态变量与成员变量的区别？
1、所属不同
静态变量属于类，
成员变量属于对象，
2、内存的位置不同
静态变量存储在方法区的静态区
成员变量存储在堆内存当中
3、生命周期不同
静态变量随着类的加载而加载，随着类的消失而消失
成员变量随着对象的创建而创建，随着对象的消失而消失。
4、使用方法不同
静态变量可以通过类去使用，也可以通过对象使用。
成员变量只能通过对象而使用。

8、main方法讲解

 * 主方法详解
 *  public static void main(String[] args){}
 *    public：公共的，访问权限最大的，main方法是供JVM调用的，所以它的访问权限是最大的。
 *    static：静态的，可以通过类名去调用，方便JVM调用
 *    void：无返回值的，返回值是返回给方法的调用者，而主方法的调用者是JVM，返回值对JVM无任何意义。
 *    String[] args：字符串数组
 *

在这里插入图片描述
在这里插入图片描述

9、生成Java DOC

在这里插入图片描述
在这里插入图片描述

10、练习

package org.wdzl.unit02;

import java.util.Scanner;

/**
 * 猜数字
 */
public class MathTest {
    public static void main(String[] args) {
        //生成随机数
        int num = (int) (Math.random()*100)+1;//生成1-100之间的随机数；
        //Scanner对象
        Scanner scanner = new Scanner(System.in);
        while (true){
            System.out.println("请输入一个数字");
            int userNum = scanner.nextInt();
            //比较
            if (userNum == num){
                System.out.println("程序结束");
                break;
            }else if(userNum > num){
                System.out.println("输入的数字过大");
            }else if (userNum < num){
                System.out.println("输入的数字过小");
            }
        }
    }
}

11、代码块

**局部代码块：**局部位置，用于限定变量的生命周期。
**构造代码块：**在类的成员位置，用花括号扩起来的代码。
执行顺序：先于构造方法执行。
作用：将多个构造方法相同的代码块放到构造代码块中，对对象进行初始化。
**静态代码块：**在类的成员位置，用花括号括起来的代码，使用static来修饰。
执行顺序：在类的加载的时候执行。
作用：对类进行初始化。

package org.wdzl.unit02;

/**
 * 代码块：
 *         局部代码块：局部位置，用于限定变量的生命周期的。
 *         构造代码块：在类中成员的位置，用花括号扩起来的代码,
 *                   执行顺序，先于构造方法执行，
 *                   他的作用是将多个构造方法共同的代码放到一起，对对象进行初始化。
 *         静态代码块：在类中成员位置，用花括号括起来的代码，并且有static关键字来修饰，
 *                   执行顺序：在加载类的时候执行，作用对类进行初始化操作。
 */
public class CodeDemo {
    //静态代码块
    static {
        System.out.println("static code");
    }
    //构造代码块
    {
        int y = 200;
        System.out.println(y);
    }
    public CodeDemo(){
        System.out.println("CodeDemo");
    }
    public CodeDemo(int a){
        System.out.println(a);
        System.out.println("CodeDemo");
    }
    {
        int z = 300;
        System.out.println(z);
    }

    public static void main(String[] args) {
        //局部代码块
        {
            int x = 100;
            System.out.println(x);
            System.out.println("----------");
        }
//        System.out.println(x);//爆红
        CodeDemo codeDemo = new CodeDemo();
        System.out.println("----------");
        CodeDemo codeDemo1 = new CodeDemo();

    }
}

执行结果如下:
在这里插入图片描述
**面试题1：**静态代码块，构造代码块，构造方法三者的执行顺序？
1、静态代码块
2、构造代码块：只要调用的构造方法，构造代码块就执行。
3、构造方法
面试题2：
看代码，说出执行的结果

package org.wdzl.unit02;

public class Test {
    {
        System.out.println("构造代码块");
    }
    {
        System.out.println("静态代码块");
    }
    {
        System.out.println("构造方法");
    }
}
class TestDemo{
    static {
        System.out.println("TestDemo静态代码块");
    }

    public static void main(String[] args) {
        Test test = new Test();
        Test test1 = new Test();
    }
}

在这里插入图片描述

度心℃
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaSE07
CXY_ZPH的博客
08-13 188
Object类 Java.lang.Object类.根类，所有类的父类 不管是JavaAPI提供的类，还是自己自定义的类都是继承于object类，具有此类的方法 主要的方法有四个： toString(); 获取对象的详细信息.打印出对象变量的时候自动调用toString()方法,把对象的信息通过字符串返回 默认信息：对象地址   equals(); 两个对象比较判断方法; 在Obj...
java se 07
哇哇哇js
03-17 413
1:构造方法(掌握) (1)作用：对对象的数据进行初始化。 (2)特点： A:方法名和类名相同 B:没有返回值类型 C:没有返回值 (3)注意事项 A:如果我
JavaSE 07 面向对象（上）
loetca
03-28 292
JavaSE 07 面向对象（上）
Java_SE07-基本IO操作,文本数据IO操作
Lh_0618的博客
04-06 738
流 流可以读写很多设备,但是读写操作是规范的 流根据方向分为: *输入流:输入流用于“读”,将数据从外界设备读入程序 *输出流:输出流用于“写”,将数据发送到外界设备 流分为: *节点流(低级流):数据源明确,真实负责读写数据的流 *处理流(高级流):不能独立存在,需要基于其他流进行处理工作,使用高级流的目的是简化读写操作 使用文件流与RandomAccessFile读写文件的区别: *R
java基础教程----精华版
09-22
以上只是Java基础知识的一部分，实际的Java基础教程会更深入地讲解每个概念，并配有实例来帮助理解。这份"java基础教程----精华版"应该涵盖了这些主题，并且可能还有更多的实践指导和示例代码，对于学习和巩固Java...
java基础知识学习-个人笔记
10-27
Java是一种广泛使用的面向对象的编程语言，其基础知识是学习Java编程的基石。下面将详细解释标题和描述中涉及的关键...以上就是Java基础知识的一些核心概念和特性，理解并掌握这些知识点对于深入学习Java编程至关重要。
Java-Help-Document.rar_Help!
09-24
2. **面向对象编程**：Java是一种完全面向对象的语言，它支持封装、继承和多态等概念。理解类与对象的关系，以及如何通过接口实现多态性，对于编写可扩展和可维护的代码至关重要。 3. **异常处理**：Java异常处理...
JAVA-SE基础知识.pdf
08-18
这份"JAVA-SE基础知识.pdf"文档涵盖了Java编程的基础概念，对于初学者和有经验的开发者回顾基础知识都非常有用。以下是对其中一些关键知识点的详细解释： 1. **逻辑（关系）运算符**： - `==` 和 `!=` 分别用于...
JAVA的面试题-汇总！！！
04-18
以下是一些常见的Java面试题，涵盖基础知识、进阶概念以及实战应用。 1. **基础语法与特性** - 介绍Java的内存管理机制，包括栈内存和堆内存的区别。 - 讲解Java的封装、继承和多态三大特性及其应用场景。 - ...
JavaSE07_关键字之final
hoonee
05-09 436
关键字之final 概述： final:可用于修饰成员变量、方法、方法参数、类，代表最终态，不可变。 final、finally、finalize 1.final 本例已讲。 2.finally 用于异常，无论异常与否，都需要执行的代码块，通常是做一些资源回收和善后工作。 3.finalize 和垃圾回收机制有关。gc()后系统会执行finalize方法，它可能会拯救一些将被回收的
javaSE07基础-static 关键字
qq_44236958的博客
10-21 345
static 关键字 static被称为静态,可以用来修饰类的属性,方法,代码块,内部类. 修饰的成员,被所有对象所共享 不创建对象,直接被调用 优先于对象存在静态优先于非静态 类加载时执行 1.可直接通过类名访问 也可以通过对象名访问 static String school 如过不是静态,每一个对象都要复制一份变量,浪费空间, 当所有对象的某一个值都相同时,加一个static使其为静态,在内存中只有一份,所有对象共享 package com.nie.day2.Demo1; public clas
Java炒鸡重要知识点：多态！！！
James____Gosling的博客
08-04 111
多态的概述： 多态：同一操作（方法）作用于不同对象，可以产生不同的执行结果。 多态的前提和体现 ！有继承关系 ！有方法的重写 ！父类的引用指向子类的对象，简单来记就是“父父new子” package org.wdzl.unit03; /** * 同一操作作用于不同的对象，可以产生不同的执行结果 * 举例： * 父类： 宠物：叫的这个方法 * 子类： 猫：叫（）……喵喵喵 * 狗：叫（）……汪汪汪 * 多态的前提： *
Java入门之MyBatis框架学习笔记（内附源码）
zwei1999的博客
04-09 206
MyBatis 1.概述 MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁 移到了google code，并且改名为MyBatis 2013年 11 月迁移到Github。 MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了 几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置 和映射原始类型、接口和
封装和static
get棒棒的博客
09-14 1561
封装和static
java构造函数私有化_java学习-面向对象-概述-关键字-构造函数-单例
weixin_32161925的博客
02-16 228
//类与对象之间的关系：类：是对事物的描述。对象：是该类事物具体的实体。//1,用java中的类。来描述人这类事物。class Person{//定义Person的成员.//1,成员属性。String name;int age;//2,成员方法。void speak(){System.out.println("name="+name+",age="+age);}}class PersonDemo...
JavaSE07_关键字之static
hoonee
05-09 462
关键字之static 概述： 修饰方法和成员变量，一旦修饰被修饰，就属类所有，可以通过类直接调用。 静态代码块：主要功能是做一些初始化工作。 代码块可以给变量赋初始值，但是千万不要把变量定义在代码块中。 代码块不能接受参数，所以它初始化的应当是公共的相同的信息，每个类或每个对象都是一样的信息。 静态成员(field、方法、代码块)不能访问非静态的成员，因为在他们运行的时候 非静态成
黑马—private关键字-封装
conan2017的博客
12-21 249
private最常见的应用： 1、把成员变量用private修饰 2、提供对应的getXxx（）/setXxx（）方法 3、一个标准的案例的使用 直接访问存在安全问题 package blackHorse; /* * 学生类 * * 通过对象直接访问成员变量，会存在安全问题 * 这个时候，我们就想能不能不让外界的对象直接访问成员变量呢？ * 能。 * 如何实现呢？ * ...
配置Java开发环境
最新发布
Broken_x的博客
07-10 1546
Java开发环境配置
JAVA基础知识学习零基础ppt课件.ppt
11-16
总结：JAVA基础知识学习零基础课程提供了全面的Java编程入门知识。课程内容包括Java开发环境介绍、标识符、关键字和数据类型、表达式和流程控制、数组、常用数据结构和算法、面向对象编程（OOP）、封装、继承、多态...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值