Java类和对象（下篇）

本日接着学习类和对象(苦笑)(苦笑)(苦笑)
1. 封装

1.1 封装的概念

面向对象步伐三大特性：封装、继续、多态。
而类和对象阶段，重要研究的就是封装特性。
作甚封装呢？简单来说就是套壳屏蔽细节。
举例：对于盘算机利用者而言，不消关心内部核心部件，
好比主板上线路是怎样结构的，CPU内部是怎样计划的等，
用户只必要知道，怎么开机、怎么通过键盘和鼠标与盘算机举行交互即可。
因此盘算机厂商在出厂时，在外部套上壳子，将内部实现细节隐蔽起来，
仅仅对外提供开关机、鼠标以及键盘插孔等，
让用户可以与盘算机举行交互即可。
封装：将数据和利用数据的方法举行有机连合，隐蔽对象的属性和实现细节，仅对外公开接口来和对象举行交互
2.2 访问限定符

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

好比：
public：可以明白为一个人的外貌特性，谁都可以看得到
default: 对于本身家属中(同一个包中) 不是什么机密，
对于其他人来说就是隐私了
private：只有本身知道，其他人都不知道

1. public class UnderGraduate {
2.     private int height;//身高
3.     private int weight;//体重
4.     public String gender;//性别
5.     public String specialty;//专业
6.     int classandgrade;//年级和班级 -->>default属性
8.     public UnderGraduate(int height,int weight,String gender,String specialty,int classandgrade){
9.         this.height = height;
10.         this.weight = weight;
11.         this.gender = gender;
12.         this.specialty = specialty;
13.         this.classandgrade = classandgrade;
15.     }
17.     public void Sleep(){
18.         System.out.println("Slepp~~~~~~");
19.     }
21.     public void Forget(){
22.         System.out.println("Forget~~~~~~");
23.     }
25.     public void Eat(){
26.         System.out.println("Eat~~~~~~");
27.     }
29.     public class TestUndergraduate{
30.         public static void main(String[] args) {
31.             UnderGraduate g1 = new UnderGraduate(173,59,"man","computer scicence and technology",241);
32.             System.out.println(g1.height);// private属性：只能在Computer类中访问，不能被其他类访问
33.             System.out.println(g1.weight);// private属性：只能在Computer类中访问，不能被其他类访
34.             System.out.println(g1.gender); // public属性： 可以任何其他类访问
35.             System.out.println(g1.specialty); // public属性： 可以任何其他类访问
36.             System.out.println(g1.classandgrade);// default属性：只能被本包中类访问
37.         }
38.     }
39.    
40. }

复制代码

3.3 封装扩展（包）

3.3.1 包的概念

在面向对象体系中，提出了一个软件包的概念，
即：为了更好的管理类，把多个类网络在一起成为一组，称为软件包。
有点雷同于目次。好比：为了更好的管理电脑中的歌曲，
一种好的方式就是将雷同属性的歌曲放在雷同文件下，
也可以对某个文件夹下的音乐举行更具体的分类。

在Java中也引入了包，包是对类、接口等的封装机制的表现，
是一种对类大概接口等的很好的构造方式，
好比：一个包中的类不想被其他包中的类利用。
包尚有一个紧张的作用：
在同一个工程中允许存在雷同名称的类，只要处在差别的包中即可。
3.3.2 导入包中的类

Java 中已经提供了许多现成的类供我们利用.
比方Date类：可以利用 java.util.Date 导入 java.util 这个包中的 Date类.

1. public class Test {
2.    public static void main(String[] args) {
3.        java.util.Date date = new java.util.Date();
4.        // 得到一个毫秒级别的时间戳
5.        System.out.println(date.getTime());
6.   }
7. }

复制代码

但是这种写法比力贫困一些, 可以利用 import语句导入包

1. import java.until.Date;
2. // 得到一个毫秒级别的时间戳
3.     public static void main(String[] args) {
4.         Date date = new Date();
5.         System.out.println(date.getTime());
6.     }

复制代码

如果必要利用 java.util 中的其他类, 可以利用 import java.util.*

1. import java.util.*;
2. public class Test {
3.    public static void main(String[] args) {
4.        Date date = new Date();
5.        // 得到一个毫秒级别的时间戳
6.        System.out.println(date.getTime());
7.   }
8. }

复制代码

但是我们更发起显式的指定要导入的类名. 否则照旧轻易出现辩论的环境

1. import java.util.*;
2. import java.sql.*;
3. public class Test {
4.    public static void main(String[] args) {
5.        // util 和 sql 中都存在一个 Date 这样的类, 此时就会出现歧义, 编译出错
6.        Date date = new Date();
7.        System.out.println(date.getTime());
8.   }
9. }
10. // 编译出错
11. Error:(5, 9) java: 对Date的引用不明确
12. java.sql 中的类 java.sql.Date 和 java.util 中的类 java.util.Date 都匹配

复制代码

在这种环境下必要利用完备的类名

1. import java.util.*;
2. import java.sql.*;
3. public class Test {
4.    public static void main(String[] args) {
5.        java.util.Date date = new java.util.Date();
6.        System.out.println(date.getTime());
7.   }
8. }

复制代码

可以利用import static导入包中静态的方法和字段

1. import static java.lang.Math.*;
2. public class Test {
3.     // 静态导入的方式写起来更方便一些
4.     public static void main(String[] args) {
5.         double x = 48;
6.         double y = 55;
7.         double result = sqrt(pow(x,2)+pow(x,2));
8.         System.out.println(result);
9.     }  
10. }

复制代码

3.3.3 自界说包

根本规则:
在文件的最上方加上一个 package 语句指定该代码在哪个包中.
包名必要只管指定成唯一的名字, 通常会用公司的域名的颠倒情势
(比方 com.xiaoxin.demo1 ).包名要和代码路径相匹配.
比方创建 com.xiaoxin.demo1 的包,
那么会存在一个对应的路径 com/xiaoxin/demo1 来存储代码.
如果一个类没有 package 语句, 则该类被放到一个默认包中.
利用步调

• 在 IDEA 中先新建一个包: 右键 src -> 新建 -> 包
  
  
  
  
• 在弹出的对话框中输入包名, 比方 com.xiaoxin.demo1
  

• 在包中创建类, 右键包名 -> 新建 -> 类, 然后输入类名即可
  
  
  
  
• 此时可以看到我们的磁盘上的目次结构已经被 IDEA 主动创建出来了
  
  
  
  
• 同时我们也看到了, 在新创建的 Test.java 文件的最上方,
  就出现了一个 package 语句
  
  
  
  

3.3.4 包的访问权限控制（举例）

UnderGraduate类位于com.xiaoxin.demo包中，

1.     public static class  UnderGraduate {
2.         private int height;//身高
3.         private int weight;//体重
4.         public String gender;//性别
5.         public String specialty;//专业
6.         int classandgrade;//年级和班级 -->>default属性
8.         public UnderGraduate(int height,int weight,String gender,String specialty,int classandgrade){
9.             this.height = height;
10.             this.weight = weight;
11.             this.gender = gender;
12.             this.specialty = specialty;
13.             this.classandgrade = classandgrade;
15.         }
17.         public void Sleep(){
18.             System.out.println("Slepp~~~~~~");
19.         }
21.         public void Forget(){
22.             System.out.println("Forget~~~~~~");
23.         }
25.         public void Eat(){
26.             System.out.println("Eat~~~~~~");
27.         }

复制代码

TestUndergraduate位置com.xiaoxin.demo1包中：

1.     public class TestUndergraduate{
2.         public static void main(String[] args) {
3.             Teat.UnderGraduate g1 = new Teat.UnderGraduate(173,59,"man","computer scicence and technology",241);
4.             //System.out.println(g1.height);// private属性：只能在类中访问，不能被其他类访问
5.             //System.out.println(g1.weight);// private属性：只能在类中访问，不能被其他类访
6.             System.out.println(g1.gender); // public属性： 可以任何其他类访问
7.             System.out.println(g1.specialty); // public属性： 可以任何其他类访问
8.             //System.out.println(g1.classandgrade);// default属性：只能被本包中类访问
9.         }

复制代码

注意：如果去掉UnderGraduate类之前的public修饰符，代码也会编译失败
3.3.5 常见的包

• java.lang:体系常用底子类(String、Object),此包从JDK1.1后主动导入。
  
• java.lang.reflect:java 反射编程包;
  
• java.net:举行网络编程开辟包。
  
• java.sql:举行数据库开辟的支持包。
  
• java.util:是java提供的工具步伐包。(聚集类等) 非常紧张
  
• java.io:I/O编程开辟包。
  

2. stiac 成员

2.1 门生类

门生类实例化三个对象s1、s2、s3，每个对象都有本身特有的名字、性别，年事，学分绩点等成员信息，这些信息就是对差别砚生来举行形貌，如下所示：

1. public class Student{
2.    // ...
3.     public static void main(String[] args) {
4.         Student s1 = new Student("xiaoxin","boy",19,59);
5.         Student s2 = new Student("HYZS","girl",18,99);
6.         Student S3 = new Student("Tsing","girl",18,100);
7.     }

复制代码

2.2 stiac 修饰成员变量

Student类中界说的成员变量，每个对象中都会包罗一份(称之为实例变量)，由于必要利用这些信息来形貌具体的门生。而现在要表现门生上课的课堂，这个课堂的属性并不必要每个门生对象中都存储一份，而是必要让全部的门生来共享。在Java中，被static修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对象，是全部对象所共享的。

2. public class Student {
3.     public String name;
4.     public String gender;
5.     public int age;
6.     public int score;
7.     public static String classroom = "JK241";
9.         //…………………………
10.        
11.         public static void main(String[] args) {
12.         Student s1 = new Student("xiaoxin","boy",19,59);
13.         Student s2 = new Student("HYZS","girl",18,99);
14.         Student s3 = new Student("Tsing","girl",18,100);
15.         
16.                 // 静态成员变量可以直接通过类名访问
17.         System.out.println(Student.classroom);
19.         System.out.println(s1.classroom);
20.         System.out.println(s2.classroom);
21.         System.out.println(s3.classroom);
22.     }
23. }

复制代码

2.3 stiac 修饰成员方法

1. public class Student {
2.     public String name;
3.     public String gender;
4.     public int age;
5.     public int score;
6.     public static String classroom = "JK241";
8. //…………………………
9. }
11.     public class TestStudent{
12.         public static void main(String[] args) {
13.             System.out.println(Student.classroom);
14.         }
15.     }
16.    
17. 编译失败：
18. Error:(10, 35) java: classRoom 在 extend01.Student 中是 private 访问控制

复制代码

1. public class Student {
2.     public String name;
3.     public String gender;
4.     public int age;
5.     public int score;
6.     public static String classroom = "JK241";
7.    
8. //…………………………
10.     public static String getclassroom(){
11.         return classroom;
12.     }
13. }
14.     public class TestStudent{
15.         public static void main(String[] args) {
16.             System.out.println(Student.getclassroom());
17.         }
18.     }

复制代码

1. public static String getClassRoom(){
2.    System.out.println(this);
3.    return classRoom;
4. }
6. // 编译失败：Error:(35, 28) java: 无法从静态上下文中引用非静态 变量 this
8. public static String getClassRoom(){
9.    age += 1;
10.    return classRoom;
11. }
13. // 编译失败：Error:(35, 9) java: 无法从静态上下文中引用非静态 变量 age

复制代码

1. public static String getClassRoom(){
2.    doClass();
3.    return classRoom;
4. }
5. // 编译报错：Error:(35, 9) java: 无法从静态上下文中引用非静态 方法 doClass()

复制代码

2.4 stiac 成员变量初始化

注意：静态成员变量一样寻常不会放在构造方法中来初始化，
构造方法中初始化的是与对象相干的实例属性
静态成员变量的初始化分为两种：当场初始化 和 静态代码块初始化。

• 当场初始化
  当场初始化指的是：在界说时直接给出初始值
  

1. public class Student {
2.     public String name;
3.     public String gender;
4.     public int age;
5.     public int score;
6.     public static String classroom = "JK241";
8. //……………………………………
9. }

复制代码

• 静态代码块初始化
  

3. 代码块

3.1 代码块的概念，代码块的范例

利用 {} 界说的一段代码称为代码块。
根据代码块界说的位置以及关键字，又可分为以下四种：

• 平凡代码块
  
• 构造块
  
• 静态块
  
• 同步代码块（后续多线程部分再学习）
  

3.2 平凡代码块

平凡代码块：界说在方法中的代码块

1.     public static void main(String[] args) {
2.         { //直接使用{}定义，普通方法块
3.             int x = 10;
4.             System.out.println("x:"+x);
5.         }
6.         int x2 = 100;
7.         System.out.println("x2:"+x2);
8.     }

复制代码

这种用法较少见
3.3 构造代码块

构造块：界说在类中的代码块 (不加修饰符)。
也叫：实例代码块。构造代码块一样寻常用于初始化实例成员变量

1. public class Student {
2.     //实例成员变量
3.     public int age;
4.     public int score;
5.     public String gender;
6.     public String name;
7.     public int classandgrade;
9.     public Student(){
10.         System.out.println("I am a computer major student");
11.     }
13.     //实例代码块
14.     {
15.         this.score = 59;
16.         this.name = "xiaoxin";
17.         this.gender = "boy";
18.         this.age = 19;
19.         this.classandgrade = 241;
20.         System.out.println("I am computer major student");
21.     }
23.     public void show(){
24.         System.out.println("name："+name+"gender:"+gender+"age:"+age+"classandgrade:"+classandgrade);
25.     }
27.     public class Main{
28.         public static void main(String[] args) {
29.             Student student = new Student();
30.             student.show();
31.         }
32.     }
33. }

复制代码

3.4 静态代码块

利用static界说的代码块称为静态代码块。一样寻常用于初始化静态成员变量

1.     // 静态代码块
2.         static
3.     {
4.         classandgrade = 241;
5.         System.out.println("I am a computer major student");
6.     }

复制代码

• 静态代码块不管天生多少个对象，其只会实验一次
  
• 静态成员变量是类的属性，因此是在JVM加载类时开辟空间并初始化的
  如果一个类中包罗多个静态代码块，在编译代码时，
  编译器会按照界说的先后序次依次实验(归并)
  
• 实例代码块只有在创建对象时才会实验
  

4. 内部类

当一个事物的内部，尚有一个部分必要一个完备的结构举行形貌，
而这个内部的完备的结构又只为外部事物提供服务，
那么这个内部的完备结构最好利用内部类。
在 Java 中，可以将一个类界说在另一个类大概一个方法的内部，
前者称为内部类，后者称为外部类。内部类也是封装的一种表现

1. public class OutClass {
2.    class InnerClass{
3.    
4.   }
5. }
7. // OutClass是外部类
8. // InnerClass是内部类

复制代码

• 界说在class 类名{}花括号外部的，纵然是在一个文件里，
  都不能称为内部类
  

1. public class A{
2.    
3. }
5. class B{
6.    
7. }
8. // A 和 B是两个独立的类，彼此之前没有关系

复制代码

• 内部类和外部类共用同一个java源文件，
  但是颠末编译之后，内部类会形成单独的字节码文件
  

4.1 内部类的范例

内部类都可以在一个类的哪些位置举行界说

1. public class OutClass {
2.    // 成员位置定义：未被static修饰 --->实例内部类
3.    public class InnerClass1{
4.   }
5.   
6.    // 成员位置定义：被static修饰 ---> 静态内部类
7.    static class InnerClass2{
8.   }
9.   
10.    public void method(){
11.        // 方法中也可以定义内部类 ---> 局部内部类：几乎不用
12.        class InnerClass5{
13.       }
14.   }
15. }

复制代码

根据内部类界说的位置差别，一样寻常可以分为以下几种情势：

• 成员内部类(平凡内部类：未被static修饰的成员内部类 和 静态内部类：
  被static修饰的成员内部类)
  
• 局部内部类(不谈修饰符)、匿名内部类
  

注意：内部类实在一样平常开辟中利用并不黑白常多，
各人在看一些库中的代码时间大概会遇到的比力多，
一样平常开始中利用最多的是匿名内部类
4.2 成员内部类

在外部类中，内部类界说位置与外部类成员所处的位置雷同，
因此称为成员内部类
4.2.1 实例内部类

即未被static修饰的成员内部类

1. public class OutClass {
2.    private int a;
3.    static int b;
4.    int c;
5.    public void methodA(){
6.        a = 10;
7.        System.out.println(a);
8.   }
9.    public static void methodB(){
10.        System.out.println(b);
11.   }
12.   
13.    // 实例内部类：未被static修饰
14.    class InnerClass{
15.        int c;
16.        public void methodInner(){
17.            // 在实例内部类中可以直接访问外部类中：任意访问限定符修饰的成员
18.            a = 100;
19.            b =200;
20.            methodA();
21.            methodB();
22.            
23.            // 如果外部类和实例内部类中具有相同名称成员时，优先访问的是内部类自己的
24.            c = 300;
25.            System.out.println(c);
26.            
27.            // 如果要访问外部类同名成员时候，必须：外部类名称.this.同名成员名字
28.            OutClass.this.c = 400;
29.            System.out.println(OutClass.this.c);
30.       }
31.   }
32.   
33.    public static void main(String[] args) {
34.        // 外部类：对象创建 以及 成员访问
35.        OutClass outClass = new OutClass();
36.        System.out.println(outClass.a);
37.        System.out.println(OutClass.b);
38.        System.out.println(outClass.c);
39.        outClass.methodA();
40.        outClass.methodB();
41.        System.out.println("=============实例内部类的访问=============");      
42.        // 要访问实例内部类中成员，必须要创建实例内部类的对象
43.        // 而普通内部类定义与外部类成员定义位置相同，因此创建实例内部类对象时必须借助外部类
44.       
45.        // 创建实例内部类对象
46.        OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();
47.       
48.        // 上述语法比较怪异，也可以先将外部类对象先创建出来，然后再创建实例内部类对象
49.        OutClass.InnerClass innerClass2 = outClass.new InnerClass();
50.        innerClass2.methodInner();
51.   }

复制代码

注意：

• 外部类中的任何成员都可以在实例内部类方法中直接访问
  
• 实例内部类所处的位置与外部类成员位置雷同，
  因此也受public、private等访问限定符的束缚
  
• 在实例内部类方法中访问同名的成员时，优先访问本身的，
  如果要访问外部类同名的成员，必须：外部类名称.this.同名成员 来访问
  
• 实例内部类对象必须在先有外部类对象条件下才气创建
  
• 实例内部类的非静态方法中包罗了一个指向外部类对象的引用
  
• 外部类中，不能直接访问实例内部类中的成员，
  如果要访问必须先要创建内部类的对象
  

4.2.2 静态内部类

被static修饰的内部成员类称为静态内部类

1. public class OutClass {
2.    private int a;
3.    static int b;
4.    public void methodA(){
5.        a = 10;
6.        System.out.println(a);
7.   }
8.    public static void methodB(){
9.        System.out.println(b);
10.   }
11.   
12.    // 静态内部类：被static修饰的成员内部类
13.    static class InnerClass{
14.        public void methodInner(){
15.            // 在内部类中只能访问外部类的静态成员
16.            // a = 100;     // 编译失败，因为a不是类成员变量
17.            b =200;
18.            // methodA();   // 编译失败，因为methodB()不是类成员方法
19.            methodB();
20.       }
21.   }
22.   
23.    public static void main(String[] args) {
24.        // 静态内部类对象创建 & 成员访问
25.        OutClass.InnerClass innerClass = new OutClass.InnerClass();
26.        innerClass.methodInner();
27.   }
28. }

复制代码

注意：

• 在静态内部类中只能访问外部类中的静态成员
  如果确实想访问，我们该怎样做？
  
• 创建静态内部类对象时，不必要先创建外部类对象
  

4.3 局部内部类

界说在外部类的方法体大概{}中，
该种内部类只能在其界说的位置利用，
一样寻常利用的非常少，此处简单相识下语法格式

1. public class OutClass {
2.    int a = 10;
3.    public void method(){
4.        int b = 10;
5.        // 局部内部类：定义在方法体内部
6.        // 不能被public、static等访问限定符修饰
7.        class InnerClass{
8.            public void methodInnerClass(){
9.                System.out.println(a);
10.                System.out.println(b);
11.           }
12.       }
13.       
14.        // 只能在该方法体内部使用，其他位置都不能用
15.        InnerClass innerClass = new InnerClass();
16.        innerClass.methodInnerClass();
17.   }
18.   
19.    public static void main(String[] args) {
20.        // OutClass.InnerClass innerClass = null; 编译失败
21.   }
22. }

复制代码

注意：

• 局部内部类只能在所界说的方法体内部利用
  
• 不能被public、static等修饰符修饰
  
• 编译器也有本身独立的字节码文件，
  定名格式：外部类名字$数字内部类名字.class
  
• 险些不会利用
  

4.4 匿名内部类

蹲后续抽象与接口学习
5. 对象的打印

1. public class Person {
2.    String name;
3.    String gender;
4.    int age;
5.    public Person(String name, String gender, int age) {
6.        this.name = name;
7.        this.gender = gender;
8.        this.age = age;
9.   }
10.    public static void main(String[] args) {
11.        Person person = new Person("Jim","男", 18);
12.        System.out.println(person);
13.   }
14. }

复制代码

如果想要默认打印对象中的属性该怎样处置惩罚呢？
答案：重写toString方法即可

1. public class Person {
2.         String name;
3.         String gender;
4.         int age;
6.         public Person(String name, String gender, int age) {
7.             this.name = name;
8.             this.gender = gender;
9.             this.age = age;
10.         }
12.         @Override
13.         public  String toString(){
14.             return "["+name+","+gender+","+age+"]";
15.         }
17.         public static void main(String[] args) {
18.             Person person = new Person("Jim","男", 18);
19.             System.out.println(person);
20.         }
21.     }

复制代码

总结

学习了封装概念，访问限定符，包的有关知识，staic成员，代码块，内部类，对象的打印
本日对类和对象的学习就到这里了，如果感觉不错，渴望可以给博主点赞收藏和关注，感谢各人的支持，尚有什么标题和发起可以在品评区品评，拜拜。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金