Java类和对象（二）

小姗顶呱呱

已于 2022-09-03 22:07:43 修改

阅读量373

点赞数 8

文章标签： java 开发语言

于 2022-08-15 21:17:28 首次发布

本文链接：https://blog.csdn.net/qq_58224022/article/details/126258830

版权

封装

面向对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性。何为封装呢？简单来说就是套壳屏蔽细节。 将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
比如：对于电脑这样一个复杂的设备，提供给用户的就只是：开关机、通过键盘输入，显示器，USB插孔等，让用户来和计算机进行交互，完成日常事务。但实际上：电脑真正工作的却是CPU、显卡、内存等一些硬件元件。

Java中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者字段能否直接在类外使用。
public和private是访问修饰限定符，这些被修饰的只是在访问权限上不同。
private:只能在当前类当中访问，类外调用不了。我们对类的实现细节进行隐藏，对外只提供公开的方法供你使用。提高数据安全。
public则哪都可以访问。

private对属性的封装：

class  Person {
    private String name;


    public void setName(String name) {    //设置名字
        this.name = name;    

    }

    private void sleep(){
        System.out.println(this.name+"吃饭");
    }

    public void eat(){
        this.sleep();
    }
    public String toString(){
        return "Person{"+"name"+'}';
    }


}

public  class TestDemo {

    public static void main(String[] args) {

        Person person1 = new Person();
        person1.setName("lanlan");
           person1.eat();
        System.out.println(person1);
    }
}

输出结果：

封装拓展——包

包的本质就是文件夹

java中包是对类、接口等的封装机制的体现，是一种对类或者接口等的很好的组织方式，比如：一个包中的类不想被其他包中的类使用。包还有一个重要的作用： 在同一个工程中允许存在相同名称的类，只要处在 不同的包中即可 。

导入包：import java.util.*;//这样导入包下面的所有文件夹和类

import java.util.*;

public class Test {

public static void main(String[] args) {

Date date = new Date();

// 得到一个毫秒级别的时间戳

System.out.println(date.getTime());

}

alt+回车看到有什么包可以导入。
但是还是更建议指定要导入的类名，否则还是容易出现冲突

（冲突示范）

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

}

运行结果

// 编译出错

Error :( 5 , 9 ) java : 对 Date 的引用不明确

java . sql 中的类 java . sql . Date 和 java . util 中的类 java . util . Date 都匹配

util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义。这种情况下要使用完整的类名

import java.util.*;

import java.sql.*;

public class Test {

public static void main(String[] args) {

java.util.Date date = new java.util.Date();

System.out.println(date.getTime());

}

自定义包

操作步骤

在 IDEA 中先新建一个包 : 右键 src -> 新建 -> 包

给包命名 New Package：包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.csdn.www 或者 com.csdn.src 或者 com.csdn.demo1 (一般全是小写））。

同时我们也看到了, 在新创建的 Test.java 文件的最上方, 就出现了一个 package 语句

//package声明包

如果一个类没有package语句，则该类被放到一个默认包中。

包的访问权限

成员变量的默认权限只能在当前包当中使用

举例 int a=19; //只能在他自己的文件夹下使用，在别的文件夹里调用不了。

public int b=188; //任何包下面都可以调用，公开的。

private int c = 77; //只能在当前类中使用（要想在类外接收得要有 get+成员变量名和 set＋成员变量名接收）

常见的包

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成员

static 修饰的成员变量，称为静态成员变量 ，静态成员变量最大的特性： 不属于某个具体的对象，是所有对象所共 享的。Java 中，被 static 修饰的成员方法称为静态成员方法，是类的方法，不是某个对象所特有的 。静态成员一般是通过静态方法来访问的。

静态的成员变量和静态的成员方法，都不依赖于对象。因为他们是类变量。通过类名来访问。

public class Student{

public String name;

public String gender;

public int age;

public double score;

public static String classRoom = "306"; //放在类里面，不能放在方法里面

public static void main(String[] args) {

// 静态成员变量可以直接通过类名访问

System.out.println(Student.classRoom);

输出：306

1.普通的成员方法当中是可以使用静态成员变量的。

2.静态的成员方法中，不能访问任何非静态成员变量和成员方法，非静态的成员变量需要依赖于对象。

public static String getClassRoom(){

age += 1;

return classRoom;

}

// 编译失败： Error:(35, 9)

//java: 无法从静态上下文中引用非静态变量 age

静态变量（也叫类变量）存储在方法区当中

生命周期伴随类的一生(即：随类的加载而创建，随类的卸载而销毁)

代码块

1.实例代码块/构造代码块

2.静态代码块

3.本地代码块 (不会用到也就是普通代码块)

4.同步代码块 (目前用不到)

来看一些例子：

3.本地代码块（普通代码块）

public class TestDemo{

public static void main(String[] args){

}

1.构造代码块/实例代码块

一般用来初始化实例成员变量（就是普通成员变量，像一些属性如:name，age）

实例代码块优先于构造方法执行

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()!" );

}

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


    public Student(String name,int age,double score){
        this.name = name;
        this.age = age;
        this.score = score;
        System.out.println("调用带有三个参数的构造方法!");
    }


    public static String classes;
    {
        System.out.println("实例代码块优先于构造代码块执行,一般用来初始化上面的name,age");
    }
}

    public class TestDemo{
        public static void main(String[] args){
            Student student1 = new Student("bit",18,34.6);
        }

    }

运行结果：

实例代码块优先构造方法执行。从字节码角度看，是把实例代码块当中的内容拷贝到了构造方法之前。

2.静态代码块

用于初始化静态的数据成员

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


    public Student(String name,int age,double score){
        this.name = name;
        this.age = age;
        this.score = score;
        System.out.println("调用带有三个参数的构造方法!");
    }


    public static String classes;
    {
        System.out.println("实例代码块优先于构造代码块执行,一般用来初始化上面的name,age");
    }
    static{
        classes = "计科2002";
        System.out.println("静态代码块，一般用来初始化静态的数据成员");
    }
}



    public class TestDemo{
        public static void main(String[] args){
            Student student1 = new Student("bit",18,34.6);
        }

    }

运行结果：