java 是否存在 怎么命名

目录

前言：

1、封装

1.1、封装的概念

1.2、访问限定符

1.3、封装扩展之包

1.3.1、包的概念

1.3.2、导入包中的类

 1.3.3、自定义包

1.3.4、常见的包

1.4、封装的应用

2、static成员

2.1、再谈成员变量

2.2、static修饰成员变量

2.3、static修饰成员方法

2.4、static成员变量初始化

3、代码块

3.1、代码块概念以及分类

3.2、普通代码块

3.4、构造代码块

 3.5、静态代码块

4、对象的打印 

---

前言：

面向对象的3大特性：封装、继承、多态，今天来说一下封装，来认识一下什么是封装？封装有什么意义？

1、封装

1.1、封装的概念

面向对象程序三大特性：封装、继承、多态。而类和对象阶段，主要研究的就是封装特性。何为封装呢？简单来说就是套壳屏蔽细节。

举例来说：就电脑这样的一个复杂的设备，提供给用户的就只是：开关机、通过键盘输入、显示器、USB插孔等，让用户来和计算机进行交互，完成日常事务。但实际上：电脑工作的是cpu,显卡，内存等一些硬件元件被封装在主机中。

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

---

1.2、访问限定符

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

java中的四个访问修饰限定符：

 总结：

1.  public： 所修饰的类、变量、方法，在内外包均具有访问权限；
2. protected： 这种权限是为继承而设计的，protected所修饰的成员，对所有子类是可访问的，但只对同包的类是可访问的，对外包的非子类是不可以访问；
3. 包访问权限（default）： 只对同包的类具有访问的权限，外包的所有类都不能访问；
4. private： 私有的权限，只对本类的方法可以使用；

1、private：

2、包的访问权限（default）

只能在同一个包当中使用（同一个类、不同类都可以使用）。

 

 

3、 protectde 和public在学了继承之后再说。

---

1.3、封装扩展之包

1.3.1、包的概念

在面向对象体系中，提出里一个软件包的概念，即：为了更好的管理类，把多个类收集在一起成为一组，成为软件包。有点类似于目录。

比如：为了更好的管理电脑中的歌曲，一种好的方式就是将相同属性的歌曲放在相同文件
下，也可以对某个文件夹下的音乐进行更详细的分类。

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

---

1.3.2、导入包中的类

举例说明：数组当中说过的Arrays，在使用的时候要导包 import java.util.Arrays;用import关键字将某个类（Arrays）的路径导入当前类中。

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

更简洁的写法：使用import语句导入包

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

当然我们要使用一个包（java.util）当中的其他类,可以使用 import java.util.*

import java.util.*;//这里表示的是通配符
public class Test {
      public static void main(String[] args) {
            Date date = new Date();
            System.out.println(date);
     }
}

我们使用那个类，它默认就导入那个类，但是他和C语言当中的#include不相同，在C语言当中通过#include将所有的代码都到导进来，但是在Java当中，他并不会直接将一个包当中所有的类都导入，只会将需要的类导入，随用随取，用到那个类就导哪个类。

但是我们更建议显式的指定要导入的类名. 否则还是容易出现冲突的情况.

 这时候就需要这样改

 总结：

• 当用到一个包当中的多个类，可以使用  .*来使用一个包当中的多个类
• 当两个包当中有相同的类名，就要使用完整的写法。例如import java.util.Date和import java.sql.Date
• import 和 C++ 的 #include 差别很大. C++ 必须 #include 来引入其他文件内容, 但是 Java 不需要。
• import 只是为了写代码的时候更方便. import 更类似于 C++ 的 namespace 和 using

---

 1.3.3、自定义包

基本规则

• 在文件的最上方加上一个 package 语句指定该代码在哪个包中.
• 包名需要尽量指定成唯一的名字, 通常会用公司的域名的颠倒形式(例如 com.bit.demo1 ).
• 包名要和代码路径相匹配. 例如创建 com.bit.demo1 的包, 那么会存在一个对应的路径 com/bit/demo1 来存储代码.
• 如果一个类没有 package 语句, 则该类被放到一个默认包中.

操作步骤 

1、在IDEA中先新建一个包：右键 src -> 新建 ->包

 2、在弹出的对话框中输入包名，例如com.baidu.www

3、生成一个Java文件 

4、此时可以看到我们的磁盘上的目录结构已经被IDEA自动创建出来了

Test.java,在文件的最上面出现了一个package 语句

---

1.3.4、常见的包

1、java.long:系统常用基础类（String、Object），此包从JDK1.1后自动导入。

2、java.lang.reflect:java 反射编程包；

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

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

5、java.util:是java提供的工具程序包。（集合类等）非常重要

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

---

1.4、封装的应用

看代码

问题： 当属性和方法都被private修饰后，怎样在同一个包低下的另一个类当中使用。

解决方法一：想要在Test类当中使用属性name和方法eat，可以使用构造方法来解决这一问题 

 

这里提一个小知识点，在使用构造方法时，当有多个属性的时候，我们需要多个创建构造方法时可以通过这个方法类创建

1、第一步

2、第二步

3、第三步

  虽然通过构造方法可以对属性赋值，但是使用构造方法解决这个问题有局限性，只能使用一次，随着程序的运行当我们需要修改属性的值，不可能再创建一个对象，这里我们应该怎样做？

解决方法二：可以通过公开的接口来解决。

就上述代码而言：name和age被private修饰，通过公开的方法来对name和age进行修改。

这里通过getName和setName来实现对封装的name进行交互。 

当然在有多个属性的情况下，每个属性都需要自己写get和set吗？当然不需要这里来说一个idea提供的一个简便方法

1、第一步

2、第二步

3、第三步

 这样就自动生成了公开的接口

---

2、static成员

2.1、再谈成员变量

创建一个学生类

 

从上述代码调试中可以看到，三个学生对象的教室都一样，这个教室的属性并不需要每个学生对象中都存储一份，而是要让所有的学生来共享。这个时候就可以使用static这个关键字。

---

2.2、static修饰成员变量

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

【静态成员变量属性】

1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中
2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问
3. 类变量存储在方法区当中（静态成员变量也被称为类变量和类成员）
4. 生命周期伴随类的一生（即：随类的加载而创建，随类的卸载而销毁）

从这里可以看出被static修饰的成员变量是静态成员变量，不属于某个对象，是所有对象共享的。

那我们该如何访问这个静态成员变量呢？

先用对象的引用来试一试

 这样访问也可以，编译器不会报错，但是会报警告。

 更标准的写法就是用类名访问

 

这里有一个问题？

一般类中的数据成员都设置为private，而成员方法设置为public，那设置之后，Student类中classRoom属性如何在类外访问呢？

我们可以通过创建接口来实现修改值和返回值

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

---

2.3、static修饰成员方法

【静态方法特性】

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

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

3、静态方法中不能调用任何非静态方法，因为非静态方法有this参数，在静态方法中调用的时候无法传递this引用

静态方法中调用静态方法

 静态方法中调用非静态方法

4、不能在静态方法中直接访问任何非静态成员变量

非静态成员变量和方法想要在静态方法中使用，需要实例化一个对象）

普通方法内部中可以直接使用静态成员方法

总结：

我们建议：获取静态的成员变量或者是设置静态成员变量，此时的方法最好是静态的，若方                    法是非静态的，还得要实例化对象。

---

2.4、static成员变量初始化

对于静态成员变量的初始化：

1、直接赋值

2、默认初始化

3、可以通过提供get和set方法来进行初始化

4、在构造对象的时候，可以在构造方法中经行赋值 （这样写可以实现目的，但是不建议）

5、 通过静态代块来进行赋值

那什么是代码块那？继续向下看：）

---

3、代码块

3.1、代码块概念以及分类

使用{}定义的一段代码称为代码块，更具代码块顶柜的位置以及关键字，又可以分为以下四种：

• 普通代码块
• 构造块--->非静态代码块/实例代码块
• 静态块
• 同步代码块（后续讲解多线程部分再谈）

3.2、普通代码块

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

 普通代码块的作用（用的不多）

3.4、构造代码块

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

1、代码中的执行顺序：

2、初始化成员变量

第一种情况：带有参数的构造方法和构造代码块之间执行的先后顺序

第二种情况：不带参数的构造方法和构造代码块之间执行的先后顺序

 

第三种情况：非静态代码块和非静态成员之间执行的先后顺序

总结：

实例代码块在实际应用中不是很多，实际在写代码的时候就通过实例化对象的时候进行赋值就行。

---

 3.5、静态代码块

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

 

 静态的方法和成员变量是不依赖于对象的，所以代码可以这样写。

 当生成多个对象的时候，静态的代码块被执行几次？

 总结：

静态代码块的注意事项：

• 静态代码块不管生成多少个对象，其只会被执行一次
• 静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
• 如果一个类中包含多个静态代码块，在编译时，编译器会按照定义的先后次序依次执行（合并）
• 实例代码块只有在创建对象的时候才会执行 

---

4、对象的打印 

这样写是一个常见的写法，利用自己写的show方法打印

class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
     public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void show() {
        System.out.println(name+" "+age);
    }
}
public class Test2 {
      public static void main(String[] args) {
            Person person = new Person("zhangsan",10);
            person.setName("lisi");
            System.out.println(person.getName());
            person.show();
      }
}

但是如不用show方法打印，来看一下代码

class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
     public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void show() {
        System.out.println(name+" "+age);
    }
}
public class Test2 {
      public static void main(String[] args) {
             Person person = new Person("zhangsan",10);
            System.out.println(person);
//打印的结果是person引用的值，这个值指向的结果是zhangsan  10
      }
}

这里来了解一下输出的结果 

 println函数调用方法的底层是toString方法

 我们可以自己写一个toString方法，来将name和age的结果打印出来

class Person {
    private String name;
    private int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
     public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public void show() {
        System.out.println(name+" "+age);
    }
    //自己写一个toString方法
     @Override//这个是注解
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class Test2 {
      public static void main(String[] args) {
             Person person = new Person("zhangsan",10);
            System.out.println(person);
      }
}

 总结：

对于你想输出一个对象的引用的值的时候，如果你没有自己写一个toString方法，那么就会调用Object这个类的方法。

如果自己写了，就会调用自己的！！！

---

5、作业练习 

1、如下代码的输出结果是什么？（D）

public class Test { 
    public int aMethod(){
        static int i = 0;
        i++; 
        return i;
    } 
public static void main(String args[]){
    Test test = new Test(); 
    test.aMethod(); 
    int j = test.aMethod();
    System.out.println(j);
    } 
}

选项：

A.0       B.1     C.2       D.编译失败   

答案解析：

在方法当中定义的变量是局部变量，而静态的变量属于类变量。随着类的加载而被创建，而局部变量是调用该方法的时候，才创建的。

所以，此时两种变量的性质是冲突的。Java当中不允许定义局部的静态变量。

---

 2、当你编译和运行下面的代码时，会出现下面选项中的哪种 （B）

public class Pvf{
    static boolean Paddy;
    public static void main(String args[]){
        System.out.println(Paddy);
    }
}

选项：

A.编译时错误

B.编译通过并输出结果false

C.编译通过并输出结果true

D.编译通过并输出结果null

答案解析：

在Java当中，成员变量没有赋初值的时候，会有默认的初始值。基本类型是对应的0值。如：int是0，boolean是false,char类型是'\u0000'，引用类型是null，如String。

---

3、 已知如下类说明：

public class Test{

  private float f=1.0f;

  int m=12;

  static int n=1;

  public static void main(String args[]){

    Test t=new Test();

  }

}

如下那些在main函数中使用是正确的（D）

选项：

A.t.f = 3.0

B.this.n

C.Test.m

D.Test.n

答案解析：

A：f是float类型，3.0默认是double，所以此时不能赋值

B：n是静态的，需要通过类名访问，不能通过this访问，this代表当前对象的引用，但是静态的成员变量不属于this。

C：m是实例成员变量，需要通过对象来进行调用。

D：正确

故：答案选D

---

4、关于以下程序的说明正确的是（A）

public class HasStatic {// 1
	private static int x = 100;// 2
	public static void main(String args[]) {// 3
		HasStatic hsl = new HasStatic();// 4
		hsl.x++;// 5
		HasStatic hs2 = new HasStatic();// 6
		hs2.x++;// 7
		hsl = new HasStatic();// 8
		hsl.x++;// 9
		HasStatic.x--;// 10
		System.out.println(" x=" + x);// 11
	}

选项：

A.程序通过编译，输出结果为:x=102

B.程序通过编译，输出结果为:x=103

C.10行不能通过编译.因为x星私有静态变量

D.5行不能通过编译.因为引用了私有静态变量

答案解析：

1. 本题中的静态成员变量x，属于类变量，只有一份。所有对x的操作针对的都是同一份。
2. 静态成员变量的访问需要通过类名访问，这是正确的访问方式。本题中虽然使用了对象引用访问，但是不会报错，我们不建议这样访问，但不是错误，所以，不会编译报错。

综合以上2点，得出结论：本题可以正常通过编译和运行，输出结果是102

---

5、

public class Test{
    static int cnt = 6;
    static{
        cnt += 9;
    }
    public static void main(String[] args）{
        System.out.println（"cnt = " + cnt);
    }
    static{
        cnt /=3;
    };
}

 cnt的值是（）

选项：

A.cnt=5    B. cnt=2    C.cnt=3     D.cnt=6

答案解析：

本题考察的是代码块的执行顺序。带代码中存在代码块和构造方法的时候。执行顺序为：

1.静态代码块

2.实例代码块

3.调用的对应的构造方法

第2种情况：当存在相同类型的代码块和成员变量的时候，需要看定义顺序执行。

---

6、给定以下代码：

class Test{	
	public String toString() {
		System.out.print("aaa");
		return "bbb";
	}
}

public static void main(String[] args) {
    Test test = new Test();
	System.out.println(test);
}

程序输出结果为（）

选项：

A.aaa   B.bbb    C.aaabbb     D.bbbaaa

答案解析：

本题中主要考察toString 方法

在执行println函数的时候，会调用Object类的toString方法，此时当我们自己类重新通过编译器实现了toString方法之后，会调用我们自己写的方法。此处具体的原因，我们会在继承，多态章节讲到的。大家先用起来。

根据上面所述，调用我们自己写的toString方法后，执行输出语句，输出aaa,返回bbb交给println函数，输出bbb。