Java类和对象（二）

爱塔居

于 2022-11-14 00:53:03 发布

阅读量587

点赞数 2

文章标签： java 学习

本文链接：https://blog.csdn.net/m0_65683419/article/details/127814368

版权

作者：爱塔居的博客_CSDN博客-领域博主

专栏：JavaSE

🍓🍓🍓🍓🍓

今天也要好好学习呀~冲！

文章目录

前言
一、pandas是什么？
二、使用步骤
- 1.引入库
- 2.读入数据
总结

前言

面对对象程序三大特性：封装、继承、多态。

一、封装

在类和对象阶段，主要研究的就是封装特性。

1.1 封装的概念

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互，简单来说就是套壳屏蔽细节。

比如：我们的电脑，真正工作的是CPU、显卡、内存等。而对于计算机使用者来说，不用关心内部核心不见，不用关心主板线路布局，CPU内部设计等，所以计算机厂商在出厂时在外部套上壳，只提供开关机、键盘插件、鼠标等，让用户可以与计算机进行交互。所以，我们所能看到的是：

1.2 访问限定符

🍧🍧Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知。而访问权限用来控制方法或者字段能否直接在类外使用。

学完访问限定符，我们就能解决之前的一个困惑啦~什么时候要加public？

什么时候要加什么访问修饰符，为什么要加访问修饰符，这种问题就可以迎刃而解了！

	范围	private	默认权限	protected	public
1	同一包中的同一类	✔	✔	✔	✔
2	同一包中的不同类		✔	✔	✔
3	不同包中的子类			✔	✔
4	不同包中的非子类				✔

【说明】

1、protected主要是用在继承中

2、默认权限指的是什么都不写的情况

3、访问权限除了可以限定类中的成员可见性，也可以控制类的可见性

4、一般情况下成员变量设置为private，成员方法设置为public

1.3 软件包

1.3.1 包的概念

🌳🌳软件包：为了更好地管理类，把多个类收集在一起成为一组。包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式。而且，在同一个工程中允许存在相同名称的类，只要处于不同的包即可。

1.3.2 导入包中的类

java中已经提供了很多现成的类供我使用，例如Date类：可以使用java.util.Date导入java.util这个包中的Date类。

public class Test {
    public static void main(String[] args) {
        java.util.Date date=new java.util.Date();
        System.out.println(date.getTime());
    }
}

不过，直接用import语句导入包的写法会比较简便一些，效果是一样的在。

import java.util.Date;
public class Test {
    public static void main(String[] args) {
        Date date=new Date();
        System.out.println(date.getTime());
    }
}

如果需要使用java.util中的其他类，可以使用import java.util.*

import java.util.*;
public class Test {
    public static void main(String[] args) {
        Date date=new Date();
        Scanner scanner=new Scanner(System.in);
        int a=scanner.nextInt();
        System.out.println(date.getTime());
    }
}

比如这个代码中，我们需要用到Date类和Scanner类,这两个类都是java,util中的类。所以，用import java.util.*; 就可以啦。不过，还是更建议指定要导入的类名，否则还是容易出现冲突的情况。

import java.util.*;
import java.sql.*;
public class Test {
    public static void main(String[] args) {
// util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
        Date date = new Date();
        System.out.println(date.getTime());
    }
}

编译错误：

1.3.3 自定义包

🌹基本规则：

1.在文件的最上方加上一个package语句指定该代码在哪个包中

2.包名需要尽量指定成唯一的名字，通常会用公司的域名的颠倒形式

3.包名要和代码路径相匹配，例如创建com.baidu.www的包，那么会存在一个对象的路径com/baidu/www来存储代码

4.如果一个类没有package语句，则该类被放在一个默认包中

src相当于是java中默认的包。

🍓🍓操作步骤

在src处右键，找到NEW（第一行），选择Package选项，在弹出的对话框中输入包名回车即可。

如果回车后，是一行，那么也很正常。

勾选 Tree Appearance，点击Compact Middle Packages即可。

新建一个类

说明当前类在哪个包底下。

1.3.4 常见的包

1. java.lang: 系统常用基础类 (String 、 Object), 此包从 JDK1.1 后自动导入。

2. java.lang.reflflect:java 反射编程包 ;

3. java.net: 进行网络编程开发包。

4. java.sql: 进行数据库开发的支持包。

5. java.util: 是 java 提供的工具程序包。

6. java.io:I/O 编程开发包。

二、static成员

在java中，被static修饰的成员，称之为金泰成员，也可以称为类成员，其不属于某个具体的对象，是所有对象所共享的。

2.1 static修饰成员变量

🍹🍹成员变量分为：

1.静态成员变量/类变量或者类成员

2.非静态成员变量/普通成员变量

static修饰的成员变量称为静态成员变量。静态成员变量最大的特性：不属于某个具体的对象，是所有对象共享的。

🌺【静态成员变量特性】

1.不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中。

class Student{
  public String name;
  public int age;
  String classroom="1班";
  public void show(){
      System.out.println(name+" "+age+" "+classroom);
  }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
public class Test {
    public static void main(String[] args) {
        Student student1=new Student("张三",12);
        Student student2=new Student("张三",12);
        Student student3=new Student("张三",12);
        System.out.println();

    }
}

在代码19行处取断点，Debug运行一下是这个样子的。

然后，我们把刚才的代码改一下，把我们的班级改成静态成员变量：

class Student{
  public String name;
  public int age;
 static String classroom="1班";
  public void show(){
      System.out.println(name+" "+age+" "+classroom);
  }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
public class Test {
    public static void main(String[] args) {
        Student student1=new Student("张三",12);
        Student student2=new Student("张三",12);
        Student student3=new Student("张三",12);
        System.out.println();

    }
}

Debug的结果是这个样子：可以看出，静态成员变量并没有存储到某个具体的对象中。静态成员变量存在方法区中。

2.既可以通过对象访问，也可以通过类名访问，但一般更加推荐使用类名访问。

这是通过对象访问：

class Student{
  public String name;
  public int age;
 static String classroom="1班";
  public void show(){
      System.out.println(name+" "+age+" "+classroom);
  }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
public class Test {
    public static void main(String[] args) {
        Student student1=new Student("张三",12);
        Student student2=new Student("张三",12);
        Student student3=new Student("张三",12);
        System.out.println(student1.classroom);
    }
}

输出结果：

通过对象访问，编译器是不报错的，只是会有警告。而且，我们会发现当我们写代码的时候，不会主动跳出classroom。因为，我们上面说过，静态变量不在对象里面。

下面是通过类名访问：

class Student{
  public String name;
  public int age;
 static String classroom="1班";
  public void show(){
      System.out.println(name+" "+age+" "+classroom);
  }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
public class Test {
    public static void main(String[] args) {
        Student student1=new Student("张三",12);
        Student student2=new Student("张三",12);
        Student student3=new Student("张三",12);
        System.out.println(Student.classroom);
    }
}

输出结果一样：

3.类变量存储在方法区中

4.生命周期伴随类的一生。随类的加载而创建，随类的卸载而销毁

2.2 static修饰成员方法

🍏🍏成员方法分为：

1.静态成员方法/类方法

2.非静态成员方法

一般类中的数据成员都设置为private，而成员方法设置为public。

Java中，被static修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的。静态成员一般是通过静态方法来访问的。

public class Student{
// ...
private static String classRoom = "Bit306";
// ...
public static String getClassRoom(){
return classRoom;
}
}
public class TestStudent {
public static void main(String[] args) {
System.out.println(Student.getClassRoom());
}
}

【静态方法特性】

1.不属于某个具体的对象，是类方法

2.可以通过对象调用，也可以通过类名，静态方法名（...）方式调用，更推荐后者

3.不能在静态方法中访问任何非静态成员变量。

4.静态方法中不能调用任何非静态成员变量，因为非静态方法有this参数，在静态方法中调用时候无法传递this引用。

2.3 static成员变量初始化

静态成员变量一般不会放在构造方法中初始化。构造方法中初始化的是与对象相关的实例属性。

静态成员变量的初始化分为两种：就地初始化和静态代码块初始化。

三、代码块

3.1 代码块概念以及分类

使用{}定义的一段代码称为代码块。

根据代码块定义的位置以及关键字，又可分为以下四种：

1.普通代码块

2.构造块

3.静态块

4.同步代码块

3.2 普通代码块

普通代码块：定义在方法中的代码块

class Student{
    public static void main(String[] args) {
        {
            int a=10;
            System.out.println(a);
        }
        int a=100;
        System.out.println(a);
    }
}

输出：

这种方法很少见。

3.3 构造代码块

构造块：定义在类中的代码块（不加修饰符），也叫实例代码块。构造代码块一般用于初始化实例成员变量

public class Student{
//实例成员变量
private String name;
private String gender;
private int age;
private double score;
public Student() {
System.out.println("I am Student init()!");
}
//实例代码块
{
this.name = "bit";
this.age = 12;
this.sex = "man";
System.out.println("I am instance init()!");
}
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
public class Main {
public static void main(String[] args) {
Student stu = new Student();
stu.show();
}
}

3.4 静态代码块

使用 static 定义的代码块称为静态代码块。一般用于初始化静态成员变量。

public class Student{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom;
//实例代码块
{
this.name = "bit";
this.age = 12;
this.gender = "man";
System.out.println("I am instance init()!");
}
// 静态代码块
static {
classRoom = "bit306";
System.out.println("I am static init()!");
}
public Student(){
System.out.println("I am Student init()!");
}
public static void main(String[] args) {
Student s1 = new Student();
Student s2 = new Student();
}
}

🍓🍓🍓

注意：

1.静态代码块不管生成多少个对象，其只会执行一次

2.静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的。

3.如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行

4.实例代码块只有在创建对象时才会执行

总结

爱塔居

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
Java类和对象（二）

面对对象程序三大特性：封装、继承、多态。🌹基本规则：1.在文件的最上方加上一个package语句指定该代码在哪个包中2.包名需要尽量指定成唯一的名字，通常会用公司的域名的颠倒形式3.包名要和代码路径相匹配，例如创建com.baidu.www的包，那么会存在一个对象的路径com/baidu/www来存储代码4.如果一个类没有package语句，则该类被放在一个默认包中src相当于是java中默认的包。🍓🍓操作步骤。
复制链接

扫一扫