Java学习之使用eclipse或者idea创建第一个项目

2025/7/26 第一次使用博客!

1.本文章主要就Java的基本语法与常见问题，非常规问题展开学习

Java是一个纯面向对象的语言，而python是一个多范式的语言。

什么是多范式？什么是纯面向对象？

可以由以下代码来比对

package com.lx.demo1;

//上海市南京路
//北京市南京路

public class Stu {

}


#python是一个多范式的编程语言，它的语法是自由的
print("欢迎各位同学了解python语言的特性")
class Stu:
pass
a = 10
print(a)
def exec():
pass

Java的主流开发工具:

eclipse和idea，vscode

Java的工程:Java project工程

Java Maven工程

2使用eclipse创建项目

下载eclipse及maven

eclipse-jee-2018-09-win32-x86_64-zhom.zip

apache-maven.rar

若使用eclipse则在下载好eclipse之后按照如下图所示创建项目

1.png

你将会看到这样的项目结构

image (1).png

在javademo1下面创建src路径，并创建包名

image (3).png

在编辑器的window（界面）选项中找到preferrence

image (4).png

在这个选项卡中我们可以改变编辑体字体的颜色，控制台样式等等

3.使用InteliJ IDEA创建一个Java项目

在已有的项目中，选择File（文件），create（新建），项目（project）

屏幕截图 2025-07-27 072920.png

命名项目名称为FirstStudy（名称随意），设置构建系统为InteliJ，语言为Java，JDK为1.8（Java8）

Java 8 下载地址:jdk-8u401-windows-x64.exe

屏幕截图 2025-07-27 073159.png

在src下创建第一个demo名称demo1（FirstStudy）

image (5).png

4.第一个程序的代码讲解

创建第一个类，命名为Stu

package com.lx.demo1;

//Stu的类名：首字母一定要大写，同时类名和文件名的名字要求一致。
public class Stu {
	//Java的入口函数,程序从哪个位置开始执行
	//Java已经完全定义好了，不能够自定义
	
	//这是一个普通正常的写法,逐字输入
//	public  static  void  main(String[]  args)
//	{
//		
//	}
	
	//我们也可以输入main 并使用快捷键 alt+/  回车（idea可以直接tab）
	 public static void main(String[] args) {
		 
		 //入口函数:最复杂的是static :静态关键字
		 //java里面的static是表示最先被加载
		
	}

}

这样我们就完成了一个入口类，兼一个Stu的对象类的创建了

Java的入口函数比较复杂，我们来逐步分析一下

package com.lx.demo1;

public class User {
	
	//main是一个入口方法，是个特殊的函数：
	//特殊：1. 是不能够由开发者自行定义
	//2.  static 静态
	//3.  Java是一个纯面向对象的语言，同时它的面向函数式编程能力是不够的。
	public static void main(String[] args) {
		
		//main方法中可以定义变量和表达式
		//如果定义的是变量，就是局部变量
		
		//局部变量，作用域只能作用与所在的函数,在这里他仅在main中起作用，其他方法无法取用
		int  a = 10;  //赋值表达式
		
		System.out.println(a);  //输出表达式
		
	    //syso  alt+/  回车  快捷键(idea可用sout并tab)
		
		//java里面的一个方法内部可以再定义一个方法吗？不可以。
	
		//Java是一个纯面向对象的语言，同时它的面向函数式编程能力是不够的。
	//例:(可自行复制并粘贴到编辑器取消注释查看是否会出现错误)
//		public   void  checkA()
//		{
//			
//		}
       
	
	}
	//正确写法：写在User类中，与main并列
	public   void   show()
	{
		   System.out.println(a);
	}
	

}

若我们声明的变量不在main方法中，而声明在User类下，那么这些变量就会成为类User的属性。

类体中的变量分为两个，一是实例变量，二是静态变量，静态变量用static修饰，实例变量则直接声明。

例如:

package com.lx.demo1;

public class Emp {
	
	int  b  = 10;  // 实例变量   没有static修饰的变量   实例化对象后使用的变量，这个变量属于这个对象
	
	static  int  c  = 20;  // 静态变量  static关键字修饰的变量  ，也叫做类变量，这个变量属于这个类的
	
//无论是实例变量还是静态变量，他们都能被其他的类以一定方式访问。声明的变量属于该类

//局部变量则只能在方法体中访问，除了定义的方法带有返回参数，否则变量只会在方法体中使用而不传播，最终被垃圾回收

	
	public static void main(String[] args) {
		
//Java的局部变量只能在所在的方法直接使用,局部变量定义时不能加访问修饰符[public  protected   prviate ].
		//例:private int errorItem

//局部变量也不能加static关键字
		//例:static int a =10

//以上两种写法都是错误的

		int  a  =10 ;
		System.out.println(a);
		
		//在main方法中可以直接使用静态变量，因为main就是一个static修饰的方法
		System.out.println(c);
		
		//在main函数中不可以直接使用非静态变量（也就是实例变量），类变量
	//	System.out.println(b);  //错误
		//实例变量，实例化后才可以使用的变量
		
		//创建Emp这个类的对象,实例化的对象
		//类创建对象的模板   类名  对象名 =  new   类名();
		//可以使用中文作为变量名，但是建议不使用
		Emp  emp  = new Emp();
		System.out.println(emp.b);
		
	}

}

//int  b  =10;  不能出类体定义变量

5.Java的内存创建，访问机制

引用类型？非引用类型？

Java中，除八大基本数据类型之外(int,double,float,byte,short,long,char,boolean)，所有由类创建的变量都为引用类型，如String类,普通类创建的变量，而由基本数据类型创建的变量为非引用类型，直接由变量存储。

无论是引用类型还是非引用类型，创建的变量都存在于栈内存当中。

引用类型所赋值的内容都来自堆内存。如String a = "abc",a就是引用类型，而这里abc是被作为对象创建在堆内存当中，并用a引用"abc"这个对象。

它们之间的关系可以由这样的图示关系表示

屏幕截图 2025-07-27 214738.png

而静态变量存在于全局供所有类调用，且单开一块内存存放

6.一个Java类的组成

package com.lx.demo1;

//面向过程的精华： 运算符+ 流程控制

//Java一个类的组成
public class UserOne {

	// 类体中定义的变量,在函数体之外的，都是全局变量
	int age = 0;

	static String address = "南京市";
	
	//实例方法
	void  show()
	{
		System.out.println("这是实例方法show方法");
	}
	
	//静态方法
	static  void  add()
	{
		System.out.println("这是静态方法add方法");
	}

	public static void main(String[] args) {

		//局部变量
		int count = 0;
		System.out.println(count);
		
		//main是个静态方法，在静态方法中使用实例变量，必须创建这个实例变量所在类的对象
		UserOne  uone  =   new UserOne();
		System.out.println(uone.age);//0
		
		System.out.println(address);//南京市

			//调用静态变量可以使用实例名和类名
 				//建议使用类名
		System.out.println(UserOne.address);//南京市
		System.out.println(uone.address);//南京市
		
		uone.show();//调用实例方法，还是要实例化对象名
		
		//调用静态方法，可以使用类名.静态方法名（建议），也可以使用对象名.静态方法名
		//静态方法和main函数在同一个类中，可以直接使用静态方法名。
		add();
		UserOne.add();//类名.静态方法名(推荐)
		uone.add();//对象名（实例）.静态方法名
		
	}

}

7.构造函数

与类名一致，形似下方代码块中的函数叫做构造函数，用于构建实例中的属性，以达到快速创建对象并使用的目的。

package com.lx.demo1;

public class UserTwo {
	
	//构造函数，Java中的构造函数和类名一致，参数列表不一样,不能显示的调用
//	UserTwo(byte  a)
//	{
//		System.out.println("UserTwo类的无参数的构造函数");
//	}
	
//	UserTwo(String  str)
//	{
//		
//	}
	
	//类中没有显示的提供构造函数,Java编译器一定会自动提供默认无参构造函数
	//比如一个类NoBuilder里面没有它的构造函数，那么其他类使用NoBuilder()这个字段方法的时候
	//编译器就会提供一个无参，无行为的构造函数
	//NoBuilder(){
    //           }
	UserTwo(byte  a)
	{
		
		System.out.println("UserTwo类的无参数的构造函数");
	}
	UserTwo(int b)
	{
		
	}
	UserTwo(String c)
	{
		
	}
	UserTwo()
	{
		
	}
	
	//构造函数重载，重载：一个类中，可以有多个构造函数，构造函数的参数列表不一样
	//提供了不同的创建对象入口，例子如上述UserTwo构造函数，共有4个构造函数，传入的参数不同
	//调用的构造函数就不同，其他方法函数重载同理
	//生物学的角度：1.孪生  2.传播   3.克隆	

	
	public static void main(String[] args) {
		
		//创建这个类的对象，会隐式的自动的调用类中提供的构造函数。
		UserTwo  two  =new UserTwo();
		//创建这个类的对象,一定会依赖类中提供的构造函数
		//在java中定义的整型变量，默认类型是int 
		//byte-short-int-long
		//UserTwo  two  =new UserTwo((byte)10);
		
		//UserTwo  two  =new UserTwo("李欣");
		
		

	}

}

8.特殊类

接下来我们将着重讲解一些特殊类

8.1.String

创建一个Test1类

写一个equals，并使鼠标指向equals，Ctrl + 鼠标右键可以查看当然方法属性

我们可以看到Test1类中的equals方法是这样的

public boolean equals(Object obj)
{
return (this == obj);
}

而String类中的equals是这样的

image (6).png

说明Test1和String都来自有同一个类Object类，他们都是继承于Object类而来。

但是我们能看到相较于普通类Test1，String类型的equals方法更为严谨且不同。

什么是继承？以后我们会有更深刻的讨论。

String类型为什么特殊？

package com.lx.demo1;

public class Test1 {
	
	public static void main(String[] args) {
		
		//String类型是Java中特殊的类型的两个其中之一：
		
		//String类型是个引用类型，但是自身的特殊在于：1.可以直接赋值  ；2. 也可以new对象
		String  s1 = "123";
		
		String  s2 = new String("123");
		
		//String是引用类型，== 比较的是地址
		System.out.println(s1 == s2);
		
		//判断是字符串的值是否相等equals 
		System.out.println(s1.equals(s2));//来自于String类自己定义的equals
		
		
		//除了String类和封装类这两个类，其他所有的类，equals都来自于Object类，比较的都是地址
		Test1  t1   =new Test1();
		Test1  t2   =new Test1();
		System.out.println(t1 == t2);//false 
		System.out.println(t1.equals(t2));//false
		
		
	}

}

Java语言入门为抓手，主要的主线是Java一个类的组成，全面的了解并实践Java是个纯面向对象的语言。

  1. Java是从定义Class开始

  2. Java的入口函数是严格定义 的public static void main(String[] args)

  3. Java的变量和方法定义，主要是实例和静态区别，从作用域角度是全局和局部。

  4. Java的变量类型：Java引用类型 Java基本数据类型

Java的引用类型有：class类，接口，数组，枚举

class类有两个特别的类：String类和封装类

8.2.封装类

我们将用代码展示为何封装类特殊

package com.lx.demo1;

import java.util.Random;

public class Test2 {
	
	public static void main(String[] args) {
		
		//s还是声明在栈内存，"123"没有去new，它是存放在字符串池中
		//池内存，解释一下： 反复使用的一个内存地址。（你开个饭店：设计一个类，筷子和碗就是池内存，反复使用这个对象）
		//对于一个饭店来说：每天的菜是不是在堆内存，新买的菜。饭店的空调是类变量，静态变量。
		String  s  = "123";
		
		//java里面只要看到new，一定是堆内存开辟内存空间，内存空间会指向池中的存放"123"这个值的池内存。
		String  s1  = new String("123");
		
		//池的构建，会在多线程，去手写线程池。场景： 多线程+池+Socket编程  
		
		//java的引用类型：定义class 一般类，String类, 封装类(基本数据类型对应的类的类型：int->Integer,short->Short)
		
		//int属于基本数据类型
		int  a = 10;
		
		//Integer类型就是int类型对应的class类的类型，封装类
		Integer  a1  =  10;
		
		Integer  a2  = new Integer(10);
		
		//Java除了String和封装类(基本数据类型对应的class类型)，可以直接赋值或new创建对象，
		//其它的class定义的类都直接赋值为null或new创建对象来赋值,如果是null对象，使用肯定会抛出空对象异常。
		Random  r  = null;//
		Test2 t2 = new Test2();	
	}

}


package com.lx.demo1;

public class Test3 {

	public static void main(String[] args) {

		// 封装类的缓冲池
		Integer a1 = 10;

		Integer a2 = new Integer(10);

		// 比较的是地址
		System.out.println(a1 == a2);

		// 比较的是值
		System.out.println(a1.intValue() == a2.intValue());

		System.out.println("-----------------------");

		//缓冲池  复用对象 -128~127 ，到了128没有new关键字，溢出缓冲池的范围，实际去new一个对象(大于127小于-128的对象会在堆内存开辟一块新的空间并赋值，使其成为Integer对象而非数据)
		Integer a3 =  127;

		Integer a4 =  127;

		System.out.println(a3 == a4);//true  
		

		Integer a5 = 200;

		Integer a6 = 200;

		System.out.println(a5 == a6);//true 正确的是:false

	}

}

疑问：在-128~127范围内用integer创建的类究竟是什么？

总结

引用类型分为:普通类，封装类，String类

package com.lx.demo1;

public class Test4 {
	
	public static void main(String[] args) {
		
		//Java引用类型：class类
		//1. class类  普通的类(除了String和封装类)  ,String类，封装类。
		
		//Java引用类型特殊的两个:String类，封装类。
		String  s1  ="123";
		String  s2 =  new String("123");

		Integer  a1  = 100;
		Integer  a2  = new Integer(100);
		
		//Java的普通类
		Stu stu1  = null;
	    System.out.println(stu1.toString());
	    
	    
		Stu stu2 = new  Stu();
	    System.out.println(stu2.toString());
		
	}

}

9.创建第一个maven项目

Maven下载地址:apache-maven.rar

maven的第一个作用：统一配置、统一管理、统一依赖

将下载好的maven解压，并找到conf.settings.xml文件

image (8).png

我们可以更改这里的地址从而将我们所需要的包放在我们想要放在的文件夹下

打开eclipse,选择windows，preferrence，并找到图下相应位置导入maven

image (7).png

image (9).png在项目中，选择左上角的create，创建项目，选择Maven project

并指定正确的开启原型

右击项目javademo,配备正确的构建路径(IDEA可自行跳过)

删除原有的java1.5，选择Add Librart 将我们下载好的java1.8导入

完成上述步骤后你将会得到下面的项目结构（hutool请忽略）

请找到javamavendemo1下的src/main/java下包下的App.java文件，打开

你将会看到如下文件

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.lx</groupId>
  <artifactId>javamavendemo1</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>javamavendemo1</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
    
    
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.8.38</version>
</dependency>
    
    
    <dependency>
	<groupId>com.google.zxing</groupId>
	<artifactId>core</artifactId>
	<version>3.3.0</version>
</dependency>
    
  </dependencies>
</project>

至此我们就完成了第一个maven项目的构建了