当前位置：首页 > news >正文

初识Java3

news 来源：原创 2025/6/17 15:18:12

一.面向对象与面向过程编程区别

二.类

1.类的定义

2.类一般格式

3.类的实例化=具体对象

4.this的使用(习惯经常用)

5.this引用

三.对象

1.初始化对象方法

2.构造方法

四.封装

1.封装：

2.拓展“包”

（1）.包概念

（2）.导入包使用的方法（三个）

（3）.自定义包

3.static成员

静态成员变量特性：

静态方法：

4.代码块

（1）.普通代码块

（2）.构造代码块

（3）.静态代码块

五.对象的打印

一.面向对象与面向过程编程区别

面对对象针对偏向与对对象的着重强调，面向过程编程过多强调的是动作（详细动作）。

例子：对于洗衣服的例子；

面向对象：用户把衣服和洗衣粉放到盆中进行清洗，

面向过程编程：

区别：面向对象着重强调对象交互，而非洗衣服的动作。

面向对象语言的三大特征：封装，继承，多态。

二.类

1.类的定义

既对事务功能的提取（抽象化）。

举例：对于洗衣机（具体事物），其标签就相当于一种类的抽象化如图红框内

2.类一般格式

//在java中定义类时需要用到class关键字
// 创建类
class ClassName{
field; // 字段(属性) 或者 成员变量
method; // 行为 或者 成员方法
}
//注意：
//类名注意采用大驼峰定义首单词大写后面小写
//成员前写法统一为public，后面会详细解释
//此处写的方法不带 static 关键字. 后面会详细解释（static为静态变量的标志，一般该变量不改变）

注意事项：

1. 一般一个文件当中只定义一个类

2. main 方法所在的类一般要使用 public 修饰 ( 注意： Eclipse 默认会在 public 修饰的类中找 main 方法 )

3. public 修饰的类必须要和文件名相同

4. 不要轻易去修改 public 修饰的类的名称，如果要修改，通过开发工具修改（其会自动更改代码中其相关位置名称）。

3.类的实例化=具体对象

ClassName classname=new ClassName //（可以把类当作一个引用类型来用）

注意：

new 关键字用于创建一个对象的实例 .

使用 . 来访问对象中的属性和方法 .

同一个类可以创建多个实例 .

个人感觉类的实例化可以理解为二位数组的感觉如图：

4.this的使用(习惯经常用)

this关键字的使用定义：this引用只指向当前对象(成员方法运行时调用该成员方法的对象)，在成员方法中所有成员变量的操作，都是通过该引用去访问。

区别：

//未使用this。
public class Date {
public int year;
public int month;
public int day;
public void setDay(int year, int month, int day){
year = year;
month = month;
day = day;
}
public void printDate(){
System.out.println(year + "/" + month + "/" + day);
}
public static void main(String[] args){
Date date=new Date;
date.setDay(1999.9,9);
date.printDate;
}}
//打印结果：0/0/0.

//使用this
public class Date {
public int year;
public int month;
public int day;
public void setDay(int year, int month, int day){
this.year = year;
this.month = month;
this.day = day;
}
public void printDate(){
System.out.println(this.year + "/" + this.month + "/" + this.day);
}
public static void main（String[] args）{
Date date=new Date;
date.setDay(1999.9,9);
date.printDate;
}}
//打印结果：1999/9/9

分析原因：第一段代码中类中的变量都是局部变量出区域就销毁了。

第二段代码中类中的变量会因为使用this一直保存下来不销毁除非该对象被销毁。

5.this引用

this 引用指向当前对象 ( 成员方法运行时调用该成员方法的对象 ) ，在成员方法中所有成员变量的操作，都是通过该引用去访问。

特点：

1. this 的类型：对应类类型引用，即哪个对象调用就是哪个对象的引用类型

2. this 只能在 " 成员方法 " 中使用

3. 在 " 成员方法 " 中， this 只能引用当前对象，不能再引用其他对象

三.对象

1.初始化对象方法

原因：当变量创造出来不进行初始化编译就会失败，必须要进行初始化

方法1：在写类的时候，其中进行变量创建的时候进行变量的赋值，（这种情况下，当进行对象创建的时候，所有变量的初始化内容都一样，后期可以更改）

方法2：在创建对象的时候在main函数中进行对象的赋值（但这需要自己创造的类中方法有存入属性信息的功能）

方法3：利用构造方法（如下）。（当不进行对象初始化的时候java默认会生成一个构造方法其内容为空）

2.构造方法

（1）.概念：构造方法(也称为构造器)是一个特殊的成员方法，名字必须与类名相同，没有返回值类型，设置为void也不行。一般情况下使用public修饰在创建对象时，由编译器自动调用，并且在整个对象的生命周期内只调用一次。（一般用于初始化对象）

（2）.构造方法可以重载(用户根据自己的需求提供不同参数的构造方法)例如：

public class Date {
public int year;
public int month;
public int day;
// 无参构造方法
public Date(){
this.year = 1900;
this.month = 1;
this.day = 1;
}
// 带有三个参数的构造方法
public Date(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}
public void printDate(){
System.out.println(year + "-" + month + "-" + day);
}
public static void main(String[] args) {
Date d = new Date();
d.printDate();
}
}

注意：一旦用户定义，编译器则不再生成。如下图：

这里自己进行构造方法，但是其中没有初始化所以报错。

（3）.构造方法中，可以通过 this 调用其他构造方法来简化代码（格式如图：）

public class Date {
public int year;
public int month;
public int day;
public Date(){
this(1900, 1, 1);
//this.year = 1900;
//this.month = 1;
//this.day = 1;
}
public Date(int year, int month, int day) {
this.year = year;
this.month = month;
this.day = day;
}}

注意： this(...)必须是构造方法中第一条语句不能形成环（下图，会递归）。

public Date (){ this ( 1900 , 1 , 1 ); }

public Date ( int year , int month , int day ) { this (); }

四.封装

1.封装：

将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象，方法进行交互。

Java 中主要通过类和访问权限来实现封装：类可以将数据以及封装数据的方法结合在一起，更符合人类对事物的认知，而访问权限用来控制方法或者字段 能否直接在类外使用 。

Java 中提供了四种访问限定符：

public ：可以理解为一个人的外貌特征，谁都可以看得到

default: 对于自己家族中 ( 同一个包中 ) 不是什么秘密，对于其他人来说就是隐私了

private ：只有自己知道，其他人都不知道

protected主要是用在继承中 default 权限指：什么都不写时的默认权限

一般类中的数据成员都设置为 private ，而成员方法设置为 public，这样通过方法进行访问变量，也不会暴露变量细节。

2.拓展“包”

（1）.包概念

为了更好的管理类，把多个类收集在一起成为一组，称为软件包。

拓展：可以理解为包中有类，类中有方法。

（2）.导入包使用的方法（三个）

使用import导入包和不适用import的区别如下图，

//使用import
import java.util.Date;
public class Test {
public static void main(String[] args) {
Date date = new Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}
//当不适用import进行导入包时
public class Test {
public static void main(String[] args) {
java.util.Date date = new java.util.Date();
// 得到一个毫秒级别的时间戳
System.out.println(date.getTime());
}
}

可以理解为使用import时提前告诉程序包的位置下面使用时直接用，而不写意味着每次要在使用的时候告诉导入的包的位置。

导入包不具体明确类的方法：import java.util.*;

这样程序会直接在util包内去找要使用的方法。

但是不推荐这么做，会出现冲突，当两个不明确导入包有相同名称方法使用的时候会报错，不知道使用哪个方法，同样，即使不用*而是具体明确的两个包的导入有相同名称下面使用的时候只能写出要使用的方法的位置，不然系统无法分辨。

注意：import 和 C++ 的 #include 差别很大 . C++ 必须 #include 来引入其他文件内容 , 但是 Java 不需要 .

import 只是为了写代码的时候更方便 . import 更类似于 C++ 的 namespace 和 using

（3）.自定义包

这样在src中就有com文件夹其中有java，在其中有text。

3.static成员

在 Java 中，被 static 修饰的成员，称之为静态成员，也可以称为类成员，其不属于某个具体的对

象，是所有对象所共享的。

静态成员变量特性：

1. 不属于某个具体的对象，是类的属性，所有对象共享的，不存储在某个对象的空间中

2. 既可以通过对象访问，也可以通过类名访问，但一般更推荐使用类名访问(例如people（类名）.school（静态变量）)

3. 类变量存储在方法区当中

4. 生命周期伴随类的一生 ( 即：随类的加载而创建，随类的卸载而销毁 )

初始化：定义的时候进行初始化。

静态方法：

1. 不属于某个具体的对象，是类方法

2. 可以通过对象调用，也可以通过类名 . 静态方法名 (...) 方式调用，更推荐使用后者

3. 不能在静态方法中访问任何非静态成员变量（但是可以在非静态方法内访问静态方法）

4.代码块

使用 {} 定义的一段代码称为代码块 。

根据代码块定义的位置以及关键字，又可分为以下四种：普通代码块构造块静态块同步代码块

（1）.普通代码块

//普通代码块：定义在方法中的代码块
public class Main{
public static void main(String[] args) {
{ //直接使用{}定义，普通方法块
int x = 10 ;
System.out.println("x1 = " +x);
}
int x = 100 ;
System.out.println("x2 = " +x);
}
}
// 执行结果
x1 = 10
x2 = 100

（2）.构造代码块

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

public class Student{
//实例成员变量
private String name;
private String gender;
private int age;
private double score;
public Student() {
System.out.println("I am Student init()!");
}
//实例代码块
{
this.name = "bit";
this.age = 12;
this.sex = "man";
System.out.println("I am instance init()!");
}
public void show(){
System.out.println("name: "+name+" age: "+age+" sex: "+sex);
}
}
public class Main {
public static void main(String[] args) {
Student stu = new Student();
stu.show();
}
}
// 运行结果
I am instance init()!
I am Student init()!
name: bit age: 12 sex: man

（3）.静态代码块

使用 static 定义的代码块称为静态代码块。 一般用于初始化静态成员变量。

public class Student{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom;
//实例代码块
{
this.name = "bit";
this.age = 12;
this.gender = "man";
System.out.println("I am instance init()!");
}
// 静态代码块
static {
classRoom = "bit306";
System.out.println("I am static init()!");
}
public Student(){
System.out.println("I am Student init()!");
}
public static void main(String[] args) {
Student s1 = new Student();
Student s2 = new Student();
}
}

注意事项

静态代码块不管生成多少个对象，其只会执行一次

静态成员变量是类的属性，因此是在 JVM 加载类时开辟空间并初始化的

如果一个类中包含多个静态代码块，在编译代码时，编译器会按照定义的先后次序依次执行 ( 合并 )

实例代码块只有在创建对象时才会执行

五.对象的打印

通过system.out.println(对象);进行打印对象信息（但是tostring打印的都是地址信息），所以需要重写其中的tostring（）方法进行打印内容，如下图。

public class Person {
String name;
String gender;
int age;
public Person(String name, String gender, int age) {
this.name = name;
this.gender = gender;
this.age = age;
}
public static void main(String[] args) {
Person person = new Person("Jim","男", 18);
System.out.println(person);
}
}
// 打印结果：day20210829.Person@1b6d3586

默认打印对象中的属性该如何处理呢？答案：重写 toString 方法即可。

public class Person {
String name;
String gender;
int age;
public Person(String name, String gender, int age) {
this.name = name;
this.gender = gender;
this.age = age;
}
@Override
public String toString() {
return "[" + name + "," + gender + "," + age + "]";
}
public static void main(String[] args) {
Person person = new Person("Jim","男", 18);
System.out.println(person);
}
}
// 输出结果：[Jim,男,18]

一.面向对象与面向过程编程区别

二.类

1.类的定义

2.类一般格式

3.类的实例化=具体对象

4.this的使用(习惯经常用)

5.this引用

三.对象

1.初始化对象方法

2.构造方法

四.封装

1.封装：

2.拓展“包”

（1）.包概念

（2）.导入包使用的方法（三个）

（3）.自定义包

3.static成员

静态成员变量特性：

静态方法：

4.代码块

（1）.普通代码块

（2）.构造代码块

（3）.静态代码块

五.对象的打印

相关文章：