JavaEE - 面向对象-构造方法、封装、类加载过程

一、面向对象

概念

现实世界：

类：抽象的概念，把具有相同特征和行为的事物归为一类
先有实体，再有类的概念

代码世界：

类：抽象的概念，把具有相同属性和方法的对象归为一类
先有类，再创建对象

类的作用： 类相当于一个模板，是一组具有相同属性与方法的事物集合

类中只有属性和方法

属性也叫做全局变量，属性分为成员变量和静态变量

方法分为成员方法和静态方法

public class 类名{//成员变量数据类型 变量名;//静态变量static 数据类型 变量名;//成员方法访问修饰符 返回值类型 方法名([参数]){}//静态方法访问修饰符 static 返回值类型 方法名([参数]){}
}

1. 对象

成员属性/成员变量

语法结构：数据类型变量名;
编写的位置：类里面，方法外面

成员变量 vs 局部变量
成员变量：类里面，方法外面的变量，并且系统会赋默认值，作用在整个类中
局部变量：方法里面的变量，系统不会赋默认值，作用在方法中

成员方法

语法结构：访问修饰符返回值类型方法名([参数]){}
编写的位置：类里面

成员方法 vs 静态方法
成员方法：属于对象的方法，必须使用对象调用
静态方法：属于类的方法，使用类名调用

创建对象的语法：

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

new 类名()：属于对象，就在堆内存中开辟空间
类名对象名：对象名属于引用，存的是对象在堆内存中的地址

操作对象：

设置成员属性

访问成员属性：对象.属性

调用成员方法：对象.方法()

需求：模拟人类，并创建对象

Person.java

public class Person {//成员属性String name;int age;//成员方法public void eat(){System.out.println("吃饭饭");}//方法中的this表示调用该方法的对象public void sleep(){System.out.println(this.name + "睡觉觉");}//静态方法public static void method(){}
}

Test.java

public class Test {public static void main(String[] args) {//创建对象Person p = new Person();//设置成员变量p.name = "樱岛麻衣";p.age = 18;//访问成员变量System.out.println(p.name);System.out.println(p.age);//调用成员方法p.eat();p.sleep();//静态方法用类名调用Person.method();}
}

2.构造方法

含义： 和new一起是创建对象的功能

特点：

与类名相同的方法

没有返回项

注意：

当类中没有写构造方法时，系统会默认添加无参构造（无参数的构造方法）

构造方法可以重载的

有参构造好处： 创建对象时，把可以直接把数据赋值给该对象

public class Person{//构造方法public Person(){}//注意：这种不是构造方法，是成员方法public void Person(){}
}

需求：编写人类，操作对象

Person.java

public class Person {String name;int age;//无参构造public Person() {}//有参构造public Person(String name) {this.name = name;}public Person(String name, int age) {this.name = name;this.age = age;}public void eat() {System.out.println(this.name + "吃饭饭");}public void sleep() {System.out.println(this.name + "睡觉觉");}
}

Test.java

public class Test {public static void main(String[] args) {Person p = new Person("一之濑千鹤", 18);System.out.println(p.name);System.out.println(p.age);p.eat();p.sleep();}
}

3. private - 私有化

含义： 私有化

作用：

修饰属性：私有化属性，不能让外界使用

修饰方法：私有化方法，不能让外界使用

应用场景：不让让外界访问的属性和方法就用private修饰

需求：做实验证明private关键字作用

A.java

public class A {//私有化属性private String str;//私有化方法private void method01(){System.out.println("私有化方法");}public void method02(){//操作私有化属性this.str = "通过同一个类里的public方法操作私有化属性";System.out.println(this.str);//通过同类里的public方法调用私有方法method01();}
}

Test.java

public class Test01 {    public static void main(String[] args) {A a = new A();a.method02();}
}

4. 封装

步骤：

私有化属性

添加get（获取）/set（设置）方法

好处： 外界不可以直接操作属性，必须通过get、set方法操作，可以在get、set方法中做格外的功能

需求：模拟银行存钱

User.java

import java.time.LocalDateTime;
//用户类--封装私有化属性
public class User {private String username;private String password;private double money;public User() {}//有参构造public User(String username, String password, double money) {this.username = username;this.password = password;this.money = money;}//设置金额的方法 - set public void setMoney(double money){LocalDateTime now = LocalDateTime.now();//获取到当前系统时间System.out.println(now);this.money = money;}//获取金额的方法 - getpublic double getMoney(){return this.money;}public String getUsername() {return username;}
}

Test.java

public class Test {public static void main(String[] args) {User user = new User("一之濑千鹤", "123123", 1000);//通过get、set方法操作私有化属性user.setMoney(user.getMoney()+500);System.out.println(user.getUsername()+"有"+user.getMoney()+"存款");}
}

5. this - 本对象

含义：代表本对象，this出现方法里，表示调用该方法的对象

作用：

this.属性：调用本对象的成员变量
this.方法：调用本对象的成员方法
this()：调用本对象的构造方法（只能在构造方法中的第一句调用）

Person.java

public class Person {private String name;private char sex;private int age;public Person() {//在一个构造方法中的第一句调用另外一个构造方法this("椎名真白",'女',18);}public Person(String name, char sex, int age) {this.name = name;this.sex = sex;this.age = age;}public void eat(){//调用本对象的属性System.out.println(this.name + "吃饭饭");//调用本对象的方法this.sleep();}public void sleep(){System.out.println(this.name + "睡觉觉");}
}

Test.java

public class Test {public static void main(String[] args) {Person p1 = new Person("石原里美", '女', 18);p1.eat();Person p2 = new Person();p2.eat();}
}

6. Java包

基本作用：包主要用来对类和接口进行分类。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，可以避免名字冲突。

项目作用：项目中有众多的类，把相同功能的类放在同一个包中，方便管理
工具类：com.miku.util/tool
实体类：com.miku.vo/bean/entity
数据库类：com.miku.dao/mapper

package com.miku.util;

import 语句

在 Java 中，如果给出一个完整的限定名，包括包名、类名，那么 Java 编译器就可以很容易地定位到源代码或者类。import 语句就是用来提供一个合理的路径，使得编译器可以找到某个类。

import 语句应位于 package 语句之后，所有类的定义之前

例如，下面的命令行将会命令编译器载入 java_installation/java/io 路径下的所有类

import java.io.*;

7. static - 静态的

1. 修饰属性

类加载到方法区时，JVM会扫描该类的所有属性，并把静态属性加载到静态区中，静态属性属于类属性，该类所有的对象都共享该属性，静态属性直到项目结束时才会被回收

注意：静态属性使用类名调用

2. 修饰方法

属于类方法，直接用类名调用
应用场景：工具类

MyArrays.java

public class MyArrays {/*** 替换* @param arrays 原数组* @param value  替换的值*/public static void replace(int[] arrays, int value) {for (int i = 0; i < arrays.length; i++) {arrays[i] = value;}}}

Test.java

public class Test {public static void main(String[] args) {int[] arrays = {32, 4, 234, 2};//直接用类名调用MyArrays.replace(arrays, 888);}
}

3. 静态代码块

静态代码块在类加载到方法区时就会被调用，该代码块只能初始化静态变量
代码块在创建对象时优先于构造方法调用，该代码块可以初始化成员变量和静态变量
构造方法在创建对象时调用，该方法可以初始化成员变量和静态变量

public class A {String str1;static String str2;//静态代码块static{str2="初始化静态变量";System.out.println("A类的静态代码块"+str2);}//代码块{str1 = "初始化成员变量";//this.str1 = "初始化成员变量";str2 = "初始化静态变量";//A.str2 = "初始化静态变量"System.out.println("A类的代码块" + str1 + "--" + str2);}//构造方法public A() {str1 = "初始化成员变量";//this.str1 = "初始化成员变量";str2 = "初始化静态变量";//A.str2 = "初始化静态变量"System.out.println("A类的构造方法" + str1 + " -- " + str2);}}

成员变量 vs 静态变量
成员变量： 属于对象的变量，每个对象独享一份
静态变量： 属于类的变量，每个对象都共享一份

A.java

public class A {//成员变量String str1;//静态变量static String str2;}

Test.java

public class Test {public static void main(String[] args) {A a1 = new A();A a2 = new A();a1.str1 = "成员变量，属于对象的变量，独享1";a2.str1 = "成员变量，属于对象的变量，独享2";System.out.println(a1.str1);//输出“成员变量，属于对象的变量，独享1”System.out.println(a2.str1);//输出“成员变量，属于对象的变量，独享2”//        不应该通过类实例访问静态成员
//      a1.str2 = "xxx";
//      通过类A直接访问静态成员A.str2 = "静态变量，属于类的变量，共享1";A.str2 = "静态变量，属于类的变量，共享2";System.out.println(A.str2);//输出“静态变量，属于类的变量，共享2”System.out.println(A.str2);//输出“静态变量，属于类的变量，共享2”}
}

面试题：类加载过程的理解

class A{//类加载过程↓//准备阶段1：在静态区开辟空间//A a;//int v1;//int v2;//准备阶段2：赋系统默认值//A a = null//int v1 = 0;//int v2 = 0;//初始化阶段：private static A a = new A();//创建对象时，调用了构造方法----此时v1=1,v2=1public static int v1;     //int v1 = 1;public static int v2 = 0; //int v2 = 0;//构造方法private A(){v1++;v2++;}
}class B{//类加载过程↓//准备阶段1：在静态区开辟空间//int v1;//int v2;//B b;//准备阶段2：赋系统默认值//int v1 = 0;//int v2 = 0;//B b = null;//初始化阶段public static int v1; //int v1 = 0;public static int v2 = 0; //int v2 = 0;private static B b = new B();//创建对象时，调用了构造方法----此时v1=1,v2=1private B(){v1++;v2++;}
}public class Test {public static void main(String[] args) {//问以下代码输出结果System.out.println("A类中变量v1:" + A.v1);//v1=1System.out.println("A类中变量v2:" + A.v2);//v2=0System.out.println("B类中变量v1:" + B.v1);//v1=1System.out.println("B类中变量v2:" + B.v2);//v2=1}
}