Java基础 - 类与对象

一、类与对象的概念和特点

1.1 概念

类与对象是整个面向对象中最基础的组成单元。
类：是具有相同属性和行为的一组对象的集合，类之中定义的是属性和行为（方法）；
对象：是类的实例化，这些对象拥有类的属性和行为，即某个具体的实体，有个一个对象，这些属性才有值，这些行为才有了意义。

1.2 特点

类：是对象的数据类型；
对象：是具体的事物，是计算机中的一份数据 。

二、类与对象的定义和使用

2.1 基本语法

类：
关键字：class
语法如下：

class 类名{
         属性 (数据) ;
         行为 (方法) ;
}

其中：
属性： 表达数据
(1)用变量/常量 表达
(2)格式：[修饰词] 属性的数据类型 属性变量名; 如下：

private String userName; 
int age;

方法：表达行为
(1)用函数表达
(2)格式： [方法修饰词] 返回值类型 方法名(参数列表(参数类型 参数变量名)){ 方法体 }；如下：

public void showInfo(){ 
      System.out.println(name+"--"+age)
     }  

范例：定义一个User类

class User {     // 类名称首字母大写
    String userName ;
    private String passWord ;
    int age ;
    public void test() {        
          System.out.println("账号：" + userName + "，密码：" + passWord) ;
         }
}

类定义完成之后，肯定无法直接使用。如果要使用，必须依靠对象。
对象：
关键字：new
语法如下：

类名称 对象名称 = new 类名称 () ; //声明并实例化对象

由于类属于引用数据类型，需要内存的分配和使用。关键字new的主要功能就是分配内存空间，也就是说，只要使用引用数据类型，就要使用关键字new来分配内存空间。
范例：创建对象

User u = new User();

上述范例代码可以拆分成：

User u = null; //声明对象
u = new User(); //实例化对象

(1)user u：变量空间，可以存储对象空间的引用地址；
(2)new User()：对象空间，可以存储对象的属性（其中每执行一次对象的创建，都会在内存中创建一个对象空间，并初始化一份新的属性数据）。
我们从内存的角度分析。给出两种内存空间的概念：
（1）堆内存：保存对象的属性内容。堆内存需要用new关键字来分配空间；
（2）栈内存：保存的是堆内存的地址（在这里为了分析方便，可以简单理解为栈内存保存的是对象的名字）。

任何情况下，只要看见关键字new，都表示要分配新的堆内存空间，一旦堆内存空间分配了，里面就会有类中定义的属性，并且属性内容都是其对应数据类型的默认值。
当一个实例化对象产生之后，可以按照如下的方式进行类的操作使用：

对象.属性; //表示调用类之中的属性； 
对象.方法(); //表示调用类之中的方法。

范例：

package V;

class User {     // 类名称首字母大写
    String userName ;
    String passWord ;
    int age ;
    public void test() {        
        System.out.println("账号：" + userName + "，密码：" + passWord) ;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        User u = new User(); // 声明并实例化对象
        u.userName = "Paul"; //操作属性内容
        u.passWord = "paul123"; //操作属性内容
        u.test(); //调用类中的test()方法


    }
}

运行结果：

账号：Paul，密码：paul123

上面对象实例化对象方式内存表示如下：

2.2 对象引用传递

范例：

package V;

class User {     // 类名称首字母大写
    String userName ;
    String passWord ;
    int age ;
    public void test() {        
        System.out.println("账号：" + userName + "，密码：" + passWord) ;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        User u_1 = new User(); // 声明并实例化对象
        u_1.userName = "Paul"; //操作属性内容
        u_1.passWord = "paul123"; //操作属性内容
        User u_2 = u_1; //引用传递
        u_2.userName = "Tom";
        u_1.test(); //调用类中的test()方法


    }
}

运行结果：

账号：Tom，密码：paul123

三、静态

关键词 static，与对象无关，可以通过类名直接调用

3.1 静态变量

1.当实例变量被static修饰，表示类的属性，该类的所有对象共享这一个属性；
2.static修饰的属性在JVM方法区存储，所有该类对象共享此属性；
3.当类加载到内存中时，该类的所有static变量就会被加载到方法区中，并可直接通过类名称访问该方法，无需通过对象访问；
4.方法中不能定义静态变量。因为方法中的变量是局部变量在栈中存储，静态变量在方法区中存储，不可能一个变量存储在两个地方。
语法如下：

static 属性类型 属性名；

范例：

package V;

class User {
    String userName ;
    String passWord ;
    static int age = 10;
    public void test() {
        System.out.println("账号：" + userName + "，密码：" + passWord+ "，年龄：" + age) ;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        User u = new User();
        u.userName = "Paul";
        u.passWord = "paul123";
        u.test();
        System.out.println("-------------------------------");
        User u_1 = new User();
        u_1.age = 20;
        u.test();
        u_1.test();
        System.out.println("-------------------------------");
        User.age = 30; //用类名直接访问属性
        u.test();
        u_1.test();
    }
}

运行结果

账号：Paul，密码：paul123，年龄：10
-------------------------------
账号：Paul，密码：paul123，年龄：20
账号：null，密码：null，年龄：20
-------------------------------
账号：Paul，密码：paul123，年龄：30
账号：null，密码：null，年龄：30

3.2 静态方法

1.static修饰的方法是静态方法，没有对象也能调用；
2.静态方法不能访问成员变量和成员方法；
3.成员方法能访问静态变量和静态方法。
范例：

package V.Static;

class User02 {
    String userName ;
    String passWord ;
    static int age = 10;
    public void test() {
        System.out.println("账号：" + userName + "，密码：" + passWord+ "，年龄：" + age) ; //可以访问静态变量age
        test01(); //可以访问静态方法
    }
    static void test01(){
//        System.out.println(userName);//error（不能访问成员变量）
//        test();//error(不能访问成员方法)
        System.out.println("年龄：" + age);
        System.out.println("静态方法");
    }
}
public class Java02_Static_Method {
    public static void main(String[] args) {
        User02 u = new User02();
        u.userName = "Paul";
        u.passWord = "paul123";
        u.test();
        System.out.println("-------------------------------");
        User02.test01(); //可以用类名直接调用静态方法
    }
}

结果：

账号：Paul，密码：paul123，年龄：10
年龄：10
静态方法
-------------------------------
年龄：10
静态方法

3.3 静态代码块

3.3.1 构造代码块

1.定义在类中，使用{}括起来的代码块；
2.构造代码块优先于构造方法执行，创建几个对象就执行几次构造代码块。
范例：

package V.Static;

class Test_03{
    //构造代码块
    {
        System.out.println("构造代码块01");
    }
    //构造方法
    public Test_03(){
        System.out.println("构造方法");
    }
    {
        System.out.println("构造代码块02");
    }
}
public class Java03_构造代码块 {
    public static void main(String[] args) {
        Test_03 t_1 = new Test_03();
        System.out.println("----------------------");
        Test_03 t_2 = new Test_03();
    }
}

结果：

构造代码块01
构造代码块02
构造方法
----------------------
构造代码块01
构造代码块02
构造方法

3.3.2 静态代码块

1.定义在类中，使用使用static修饰的代码块；
2.类加载完成后，会自动调用静态代码块，但不管创建多少个对象静态代码块都只执行一次；
3.静态代码块优先于构造代码块执行。

package V.Static;

class Test_04{
    //构造代码块
    {
        System.out.println("构造代码块01");
    }
    //静态代码块
    static{
        System.out.println("静态代码块");
    }
    {
        System.out.println("构造代码块02");
    }
    static{
        System.out.println("静态代码块");
    }
}
public class Java04_静态代码块 {
    public static void main(String[] args) {
        Test_04 t_1 = new Test_04();
        System.out.println("----------------------");
        Test_04 t_2 = new Test_04();
    }
}

结果：

静态代码块
静态代码块
构造代码块01
构造代码块02
----------------------
构造代码块01
构造代码块02