Java基础 - Java基础——类 - 《Java》

类
内部类
抽象类

类

类是对某一类事物的抽象描述，而对象用于表示现实中该类事物的个体。

定义

[修饰符] class 类名{
}

定义类的注意：

如果类使用了public修饰符必须保证当前的文件名和当前类相同类名使用名称表示。
类表示某一类事物首字母大写。

public class User {
    private String name;
    private int age;
}

创建

类创建对象的语法：

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

空对象

一个引用变量没有通过new分配内存空间，这个对象就是空对象，Java使用关键字null表示空对象。当调用一个空对象的实例变量或实例方法时，会抛出空指针异常NullPointException

String str = null;
System.out.println(str.length());//java.lang.NullPointerException

内存分析

Student s = new Student();

创建了Student类的实例对象，同时把Student的对象赋值给变量s,s实际上是一个当前对象在堆内存上的引用，s被存放在栈内存中，指向实际的student的对象，而实际上Student的对象是存储在堆内存中的。变量s本身只是存储了一个地址值，并没有任何的实际值。
当一个对象被创建后，对象保存在堆内存中，Java程序不允许直接访问堆内存的对象，不管是数组还是对象，当程序访问引用变量的成员值或者方法时，实际上是访问引用变量的所指向的数组或者对象的成员变量或者方法。

this

this指向对用调用该方法的对象，主要作用让类中的方法可以访问类中的另一个方法或者实例变量
####对象的打印和比较
(1)toString()方法
(2)对象的比较操作
==对于基本数据类型比较的是双方的值
对于引用数据类型比较的是内存的中的地址，每次使用new关键字都表示的堆新开辟了一块内存空间地址值不同，如果对象拥有完全相同的数据 equals()方法
(3)对象的生命周期
每次使用new关键字的时候就会在内存开辟新的空间此时对象开始创建
对象的结束:当对象的没有被任何变量引用的时候 ,等着垃圾回收机制GCL 来回收垃圾

匿名对象

没有名称的对象创建对象之后没有赋给某一个变量
new 类名();匿名对象匿名对象只是在堆中开辟一个新的空间但是没有把空间地址赋值给任何变量
因为没有名称，匿名对象仅仅只使用了一次。一般匿名对象的作为方法的实参传递、

内部类

普通内部类

（1）普通内部类可以访问外部类的所有成员（包括外部类中的private成员,可以看做外部类的一个成员。
（2）普通内部类与外部类的实例联系，因此不能在其内部定义静态成员

public class TestInner {
    int a = 10;
    static String s = "baxiang";
    private String privateStr = "privateStr";
    class InnerClass{
        int m = 20;
        void printTest(){
            System.out.println(a);
            System.out.println(s);
            System.out.println(privateStr);
        }
    }
}

静态内部类

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

public class TestInner {
    int a = 10;
    static String s = "baxiang";
    private String privateStr = "privateStr";
    static void test(){
    }
    static class StaticInnerClass{
        void printTest(){
            System.out.println(a);// 错误无法访问
            System.out.println(s);
            System.out.println(privateStr);// 错误无法访问
            test();
        }
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
    }
}

内部类和静态内部类的区别
内部类：
1、内部类中的变量和方法不能声明为静态的。
2、内部类实例化：B是A的内部类，实例化B：A.B b = new A().new B()。
3、内部类可以引用外部类的静态或者非静态属性及方法。
静态内部类：
1、静态内部类属性和方法可以声明为静态的或者非静态的。
2、实例化静态内部类：B是A的静态内部类，A.B b = new A.B()。
3、静态内部类只能引用外部类的静态的属性及方法。

局部内部类

局部类是指定义在一个方法体内的类，局部内部类可以访问外部类的所有成员、方法的局部变量、方法的形参

void innerClassFun(){
         int b = 10;
        class innerClass{
             void testFun(){
                 System.out.println(a);
                   System.out.println(s);
                   System.out.println(privateStr);
                }
        };

匿名内部类

没有名字的内部类就是匿名内部类
(1)不能在匿名类中声明构造函数
(2)不能在匿名类中声明静态成员和接口，除非静态成员被final修饰。

class ClassTest{
     void test1(){
     }
     void test2(){
     }
}
public class TestInner {
     void fun(){
         new ClassTest(){
             void test1(){
                 super.test1();
             }
         }; 
     }
    public static void main(String[] args) {
        // TODO Auto-generated method stub 
    }
}

抽象类

abstract抽象类就是只声明方法名称而没有具体的方法体的类，需要使用abstract修饰。

定义

abstract class <类名>{
}

(1)不能实例化，无法创建对象。
(2)不能使用final修饰
(3)含有抽象方法的类只能被定义成抽象类

作用

抽象类用于被继承
抽象类可以强迫子类实现其定义的抽象方法，否则编译错误。
抽象方法实际上相当于定义了规范

抽象方法

一个类定义了方法，但是没有具体执行代码，这个方法是抽象方法，抽象方法使用abstract修饰符,抽象方法没有任何执行语句，因此方法体包括方法的花括号都需要去掉，直接在末尾加上分号。

abstract <方法返回类型> 方法名称（参数列表）;

（1）不需要方法体
（2）子类必须覆盖实现抽象方法
（3）将关键字abstract 放在最前面
（4）抽象方法必须定义在抽象类和接口中
（5）抽象方法不能使用privite 和static 修饰。
（6）因为无法执行抽象方法，抽象方法所属的类也需要声明是抽象类abstract class