JAVA学习——3.类和对象

深碍√TFBOYSˉ_ 2023-07-01 08:53 7阅读 0赞

### 目录 ###

*  类
 *  对象
 *  内部类
 *  静态内部类
 *  局部内部类
 *  匿名内部类

# 类 #

类是封装对象的属性和行为的载体，反过来说具有相同属性和行为的一类实体被称为类。  
**类的定义**

1.  类是相同或相似对象的一种抽象，是对象的一个模板，它描述一类对象的行为和状态。
2.  类是具有相同属性和方法（行为）的对象的集合  
    `属性`是对象具有的特征。每个对象的每个属性都拥有特定值.  
    Java是面向对象的语言，体现在Java程序都以类class为组织单元，而一个类是对象的抽象，所以类由属性和方法两部分组成。

**定义一个类**，主要有三个步骤：  
1、定义类名，用于区分不同的类。如下代码中 public class 后面跟的就是类名。class是声明类的关键字，类名后面跟上大括号，大括号里面就是类的一些信息。public为权限修饰符。

public class 类名{ 
    //定义属性部分（成员变量）
    属性1的类型 属性1;
    属性2的类型 属性2;
    …
    //定义方法部分
    方法1;
    方法2;
    …
    }

2、编写类的属性。对象有什么，需要通过属性来表示。属性的定义是写在类名后面的大括号里，在定义属性时，要明确属性的类型。在一个类当中可以写一个或多个属性。当然也可以不定义属性。  
3、编写类的方法。方法也是写在大括号里面。可以定义一个方法或多个方法，当然也可以不定义方法。

一个类可以包含以下类型变量：

*  局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
 *  成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
 *  类变量：也叫静态变量，类变量也声明在类中，方法体之外，但必须声明为 static 类型。

# 对象 #

创建对象的方法如下：

类名 对象名 = new 类名();

定义类的时候不会为类开辟内存空间，但是一旦创建了对象，系统就会在内存中为对象开辟一块空间，用来存放对象的属性值和方法。

**成员变量**就是指的对象的属性，是在类中定义，来描述对象的特性。还有一种变量叫**局部变量**，它是由类的方法定义，在方法中临时保存数据。  
在使用时注意，成员变量可以被本类的所有方法所使用，同时可以被与本类有关的其他类所使用。而局部变量只能在当前的方法中使用。

1.  局部变量的作用域仅限于定义它的方法内。而成员变量的作用域在整个类内部都是可见的。
2.  同时在相同的方法中，不能有同名的局部变量；在不同的方法中，可以有同名的局部变量。
3.  成员变量和局部变量同名时，局部变量具有更高的优先级。

# 内部类 #

将一个类的定义放在另一个类的定义内部，这就是内部类。而包含内部类的类被称为外部类。  
内部类的主要作用如下：

1.  内部类提供了更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中的其他类访问该类
2.  内部类的方法可以直接访问外部类的所有数据，包括私有的数据
3.  内部类所实现的功能使用外部类同样可以实现，只是有时使用内部类更方便
4.  内部类允许继承多个非接口类型（具体将在以后的内容进行讲解）

> 注：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为 outer 的外部类和其内部定义的名为 inner 的内部类。编译完成后出现 outer.class 和 outer$inner.class 两类。所以内部类的成员变量/方法名可以和外部类的相同。  
> 例如:

// People.java
    //外部类People
    public class People { 
        private String name = “LiLei”;         //外部类的私有属性
        //内部类Student
        public class Student { 
            String ID = “20151234”;               //内部类的成员属性
            //内部类的方法
            public void stuInfo(){ 
                System.out.println(“访问外部类中的name：” + name);
                System.out.println(“访问内部类中的ID：” + ID);
            }
        }
    
        //测试成员内部类
        public static void main(String[] args) { 
            People a = new People();     //创建外部类对象，对象名为a
            Student b = a.new Student(); //使用外部类对象创建内部类对象，对象名为b
            // 或者为 People.Student b = a.new Student();
            b.stuInfo();   //调用内部对象的suInfo方法
        }
    }

成员内部类的使用方法：

1.  Student 类相当于 People 类的一个成员变量，所以 Student 类可以使用任意访问修饰符
2.  Student 类在 People 类里，所以访问范围在类里的所有方法均可以访问 People 的属性（即内部类里可以直接访问外部类的方法和属性，反之不行）
3.  定义成员内部类后，必须使用外部类对象来创建内部类对象，即 `内部类 对象名 = 外部类对象.new 内部类();`
4.  如果外部类和内部类具有相同的成员变量或方法，内部类默认访问自己的成员变量或方法，如果要访问外部类的成员变量，可以使用 this 关键字 如上述代码中：a.this

> 注：成员内部类不能含有 static 的变量和方法，因为成员内部类需要先创建了外部类，才能创建它自己的。

# 静态内部类 #

静态内部类通常被称为嵌套类。

// People.java
    //外部类People
    public class People { 
        private String name = “LiLei”;         //外部类的私有属性
    
    /*外部类的静态变量。 Java 中被 static 修饰的成员称为静态成员或类成员。它属于整个类所有，而不是某个对象所有，即被类的所有对象所共享。静态成员可以使用类名直接访问，也可以使用对象名进行访问。 */
        static String ID = “510xxx199X0724XXXX”; 
    
        //静态内部类Student
        public static class Student { 
            String ID = “20151234”;               //内部类的成员属性
            //内部类的方法
            public void stuInfo(){ 
                System.out.println("访问外部类中的name：" + (new People().name));
                System.out.println("访问外部类中的ID：" + People.ID);
                System.out.println("访问内部类中的ID：" + ID);
            }
        }
    
        //测试成员内部类
        public static void main(String[] args) { 
            Student b = new Student();   //直接创建内部类对象，对象名为b
            b.stuInfo();                 //调用内部对象的suInfo方法
        }
    }

静态内部类是 static 修饰的内部类，这种内部类的特点是：

1.  静态内部类不能直接访问外部类的非静态成员，但可以通过 new 外部类().成员 的方式访问
2.  如果外部类的静态成员与内部类的成员名称相同，可通过类名.静态成员访问外部类的静态成员；如果外部类的静态成员与内部类的成员名称不相同，则可通过成员名直接调用外部类的静态成员
3.  创建静态内部类的对象时，不需要外部类的对象，可以直接创建 内部类 对象名= new 内部类();

# 局部内部类 #

局部内部类，是指内部类定义在方法和作用域内。

// People.java
    //外部类People
    public class People {     
        //定义在外部类中的方法内：
        public void peopleInfo() { 
            final String sex = “man”;  //外部类方法中的常量
            class Student { 
                String ID = “20151234”; //内部类中的常量
                public void print() { 
                    System.out.println("访问外部类的方法中的常量sex：" + sex);
                    System.out.println(“访问内部类中的变量ID:” + ID);
                }
            }
            Student a = new Student();  //创建方法内部类的对象
            a.print();//调用内部类的方法
        }
        //定义在外部类中的作用域内
        public void peopleInfo2(boolean b) { 
            if(b){ 
                final String sex = "man";  //外部类方法中的常量
                class Student { 
                    String ID = "20151234"; //内部类中的常量
                    public void print() { 
                        System.out.println("访问外部类的方法中的常量sex：" + sex);
                        System.out.println("访问内部类中的变量ID:" + ID);
                    }
                }
                Student a = new Student();  //创建方法内部类的对象
                a.print();//调用内部类的方法
            }
        }
        //测试方法内部类
        public static void main(String[] args) { 
            People b = new People(); //创建外部类的对象
            System.out.println("定义在方法内：===========");
            b.peopleInfo();  //调用外部类的方法
            System.out.println("定义在作用域内：===========");
            b.peopleInfo2(true);
        }
    }

局部内部类也像别的类一样进行编译，但只是作用域不同而已，只在该方法或条件的作用域内才能使用，退出这些作用域后无法引用的。

# 匿名内部类 #

匿名内部类，顾名思义，就是没有名字的内部类。正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写。但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口。

// Outer.java
    public class Outer {  
    
        public Inner getInner(final String name, String city) {  
            return new Inner() {  
                private String nameStr = name; 
                public String getName() {  
                    return nameStr; 
                } 
            };
        } 
    
        public static void main(String[] args) {  
            Outer outer = new Outer(); 
            Inner inner = outer.getInner("Inner", "NewYork"); 
            System.out.println(inner.getName()); 
        } 
    } 
    interface Inner {  
        String getName(); 
    }

匿名内部类是不能加访问修饰符的。要注意的是，new 匿名类，这个类是要先定义的,如果不先定义，编译时会报错该类找不到。  
同时，在上面的例子中，当所在的方法的形参需要在内部类里面使用时，该形参必须为final。这里可以看到形参 name 已经定义为 final 了，而形参 city 没有被使用则不用定义为 final。  
然而，因为匿名内部类没名字，是用默认的构造函数的，无参数的，如果需要该类有带参数的构造函数，示例如下：

public Inner getInner(final String name, String city) {  
            return new Inner(name, city) {  
                private String nameStr = name; 
    
                public String getName() {  
                    return nameStr; 
                } 
            }; 
        }

注意这里的形参 city，由于它没有被匿名内部类直接使用，而是被抽象类 Inner 的构造函数所使用，所以不必定义为 final。