初识JAVA（基本概念）

目录

计算机基础知识

JAVA基础语法

最基本的JAV代码，helloworld

JDK、JRE 和 JVM 的定义与功能

功能上的层次结构

JAVA标识符

运算符

短路逻辑运算符

流程控制语句

顺序结构

选择语句

循环语句

if语句

for循环

九九乘法表代码

力扣例题

回文数

方法

数组

Java 对象和类

Java 作为一种面向对象的编程语言，支持以下基本概念：

1、类（Class）：

• 定义对象的蓝图，包括属性和方法。
• 示例：public class Car { ... }

2、对象（Object）：

• 类的实例，具有状态和行为。
• 示例：Car myCar = new Car();

3、继承（Inheritance）：

• 一个类可以继承另一个类的属性和方法。
• 示例：public class Dog extends Animal { ... }

4、封装（Encapsulation）：

• 将对象的状态（字段）私有化，通过公共方法访问。
• 示例：

  private String name; public String getName() { return name; }

5、多态（Polymorphism）：

• 对象可以表现为多种形态，主要通过方法重载和方法重写实现。
• 示例：
  • 方法重载：public int add(int a, int b) { ... }和public double add(double a, double b) { ... }
  • 方法重写：@Override public void makeSound() { System.out.println("Meow"); }

6、抽象（Abstraction）：

• 使用抽象类和接口来定义必须实现的方法，不提供具体实现。
• 示例：
  • 抽象类：public abstract class Shape { abstract void draw(); }
  • 接口：public interface Animal { void eat(); }

7、接口（Interface）：

• 定义类必须实现的方法，支持多重继承。
• 示例：public interface Drivable { void drive(); }

8、方法（Method）：

• 定义类的行为，包含在类中的函数。
• 示例：public void displayInfo() { System.out.println("Info"); }

9、方法重载（Method Overloading）：

同一个类中可以有多个同名的方法，但参数不同。

示例：

public class MathUtils { public int add(int a, int b) { return a + b; } public double add(double a, double b) { return a + b; } }

对象：就是根据模板造出来的具体实例

张三女孩、李四女孩、王五女孩

每一个真实、具体的女孩，都是女孩类的对象

类：就是模板、图纸、统称

女孩类：规定了女孩都有：姓名、年龄、身高、会说话、会走路…

是抽象的、概念上的，不是某一个具体人

Java中的对象

软件对象也有状态和行为。软件对象的状态就是属性，行为通过方法体现。

在软件开发中，方法操作对象内部状态的改变，对象的相互调用也是通过方法来完成

类可以看成是创建 Java 对象的模板。（如图）

图源菜鸟编程

一个类可以包含以下类型变量：

局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。

成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。

类变量：类变量也声明在类中，方法体之外，但必须声明为 static 类型。

public class Dog { // ====================== // 成员变量（实例变量） // 类里、方法外、没有static // 每 new 一只狗，就自带这四个属性 // ====================== String breed; int size; String colour; int age; // ====================== // 类变量（静态变量） // 类里、方法外、加了 static // 所有狗狗共用同一个 // ====================== static String type = "哺乳动物"; void eat() { // ====================== // 局部变量 // 写在方法里面 // 只在 eat() 里能用，方法结束就销毁 // ====================== int num = 3; System.out.println("吃" + num + "碗饭"); } void run() { } void sleep(){ } void name(){ } }

构造方法

每个类都有构造方法。如果没有显式地为类定义构造方法，Java 编译器将会为该类提供一个默认构造方法。

在创建一个对象的时候，至少要调用一个构造方法。构造方法的名称必须与类同名，一个类可以有多个构造方法。

Java 分两大类：基本类型+引用类型

基本类型：byte short int long float double char boolean

除了这 8 个，剩下全是引用类型

引用类型

1. 类（class）Dog、Girl、String都是
2. 接口（interface）
3. 数组（[]）
4. 特殊：String 也是引用类型

最核心区别（超好懂）

基本类型

存的就是真实值，直接存在栈内存

int a = 10;//a 里直接装着 10

引用类型

不存真实对象，只存对象的地址（引用），对象在堆内存，变量里只是指向它的地址

Dog d = new Dog();

new Dog()：真正的狗狗对象 在堆里

d里存的不是狗狗本身，是狗狗的地址

d 就是一个引用，指向那个对象

一句话记住

• 基本类型：装值
• 引用类型：装地址，指向对象

// 引用类型变量 d Dog d = new Dog(); d.age = 3; d.run();

d 是引用类型变量，通过地址找到堆里的 Dog 对象，然后操作它的属性和方法。

Java 常量

什么是常量

固定不变、一旦赋值就不能改的变量，叫常量。

在 Java 中使用 final 关键字来修饰常量，声明方式和变量类似：

final double PI = 3.1415927;

虽然常量名也可以用小写，但为了便于识别，通常使用大写字母表示常量。

字面量可以赋给任何内置类型的变量。（写在代码里直接写死的值，就叫字面量。）

Java语言支持一些特殊的转义字符序列。

自动类型转换

JAVA基础的一些知识点（很枯燥）

疑问：为什么没有出现Hello.class？

2.1最基本的JAVA代码，helloworld

创建文件HelloWorld.java(文件名需与类名一致), 代码如下

public class HelloWorld{ public static void main(String[] args){ System.out.println("hello"); } }

2.2JDK、JRE 和 JVM 的定义与功能

JVM 是 Java 虚拟机 (Java Virtual Machine)，它是运行 Java 字节码文件 (.class 文件) 的虚拟化环境。它的作用是将字节码解释成操作系统可以识别的机器指令并执行1。

JRE 即 Java 运行时环境 (Java Runtime Environment)，包含了 JVM 和 Java 基础类库，用于支持 Java 程序的运行。换句话说，JRE 提供了一个完整的运行环境来启动和执行任何已编译好的 Java 应用程序3。

JDK 则代表 Java 开发工具包 (Java Development Kit)，是一个全面的开发环境，不仅包括了 JRE 所有的组件，还提供了额外的开发工具如javac编译器和其他调试工具等。因此，JDK 主要面向开发者，帮助他们编写、测试以及部署 Java 程序

功能上的层次结构

从功能角度来看，这三者存在一种嵌套的关系：

JVM 是核心部分，负责实际的代码执行工作；
JRE 包含了 JVM 并提供必要的类库支持，使得它可以独立于其他开发工具运行应用程序；
JDK 不仅包含 JRE 中的一切内容，还包括一系列开发所需的工具集，比如编译器 (javac) 和打包工具 (jar)

2.3JAVA标识符

标识符： 用来标识类名、对象名、变量名、方法名、类型名、数组名、文件名的有效字符序列。

合法的标识符：由字母、数字、下划线“_”、美元符号“$”或者“￥”组成，并且首字符不能是数字。
不能把java关键字和保留字作为标识符。
标识符对大小写敏感。
关键字：Java语言中已经赋予了特定含义的

2.4变量

程序运行期间可以被改变的量。在程序中使用变量，必须先创建它并为它取一个名字，并且指明它能够存储信息的类型，这称为“变量声明”，也叫容器的创建。

变量的使用：

变量的声明：数据类型 变量名;

变量的赋值：变量名 = 数据;

变量的操作：放入打印语句进行输出或者进行运算

2.5类型转换：

自动类型转换，也叫隐式转换

强制类型转换，也叫显式转换

4运算符

运算符：一种特殊符号，用以表示数据的运算、赋值和比较数与整数

运算符分类：算术运算符、赋值运算符、比较运算符、逻辑运算符、三元运算符

4.1算术运算符

4.2.赋值运算符

4.3.比较运算符

4.4.逻辑运算符

4.5三元运算符

条件表达式b?x:y;，先计算条件b，然后进行判断。如果b的值为true，计算x的值，运算结果为x的值；否则，计算y的值，运算结果为y的值。

int num=2>3?2+2:4+4; System.out.println(num);

4.6短路逻辑运算符

&&短路与

||短路或

效率更高

5流程控制语句

5.1顺序结构

5.2分支语句

switch

（把有限个数据一一列举出来，让我们任选其一）

package yixiu; public class fenzhi { public static void main(String[] args) { int number=1; switch(number){ case 1: System.out.println("number=1"); break; case 10: System.out.println("number=2"); break; case 20: System.out.println("number=3"); break; default://可以写在任意位置，最前或者最后都可以 System.out.println("number既不是1也不是2"); break;//dfault可以省略，但是不建议 } } }

case穿透

在 Java 的 switch 语句里，“case 穿透”指的是当 switch 表达式的值匹配到某个 case 标签后，若该 case 块里没有 break 语句，程序就会继续执行后续 case 块的代码，直至遇到 break 语句或者 switch 语句结束。

（有时可以利用case穿透简化代码）
下面展示 case 穿透的效果：

程序运行结果

switch 更简洁的表达方式

package yixiu;//switch另一个表达方式 public class fenzhi { public static void main(String[] args) { int number=1; switch(number){ case 1 -> System.out.println("yi"); case 2 -> System.out.println("er"); } } }

5.循环语句

5.1if语句

（对范围的判断）

import java.util.Scanner; public class ifdemo{ public static void main(String[] args) { Scanner sc=new Scanner(System.in); Systemm.out.println("请输入女婿的酒量："); int wine=sc.nextInt(); if(wine>2){ System.out.println("hao"); }else{ System.out.println("buhao"); } } }

5.2for循环

九九乘法表代码

public class text { public static void main(String[] args) { for (int i=1;i<=9;i++) { for(int j=1;j<=i;j++) { System.out.print(j+"*"+i+"="+i*j+" "); } System.out.println(""); } } }

5.2.1while循环

力扣例题

回文数

package yixiu; public class huiwenshu { public static void main(String[] args) { int x = 123456; int temp = x; int num = 0; while (x != 0) { int ge = x % 10; x = x / 10; num = num * 10 + ge; } System.out.println(num); System.out.println(x); System.out.println(num == temp); } }

循环高级

无限循环

//无限循环 //for for(;;) { System.out.println("学习"); } //while while(true) { System.out.println(" 学习"); } //do while do { System.put.println("学习"); }while(true);

5.2.2跳转循环

用到continue（结束本次循环，继续下次循环）

//跳转循环 public class fenzhi { public static void main(String[] args){ for(int i=1;i<=5;i++){ if(i==3){ continue;//结束本次循环，继续下次循环 } System.out.println("chi"+i+"baozi"); } } }

break(结束整个循环)

eg:逢七过

//逢七过代码 public class fenzhi { public static void main(String[] args){ for(int i=1;i<=100;i++) { if(i%10==7||i/10%10==7||i%7==0) { System.out.println("guo"); continue; } System.out.println(i); } } }

eg:平方根

public class liti { public static void main(String[] args) { Scanner sc=new Scanner(System.in); System.out.println("shuru"); int number=sc.nextInt(); for (int i=1;i<=number;i++) { if(i * i==number) { System.out.println(i+"shi"+number+"pingfanggen"); break; } else if (i*i>number) { System.out.println((i-1)+"shi"+number+"pingfanggen"); break; } } } }

6方法

带参数的方法

package demo; import java.util.Scanner; public class lizi6method { public static void main(String[] args) { Getsum(20,30);//实参 } public static void Getsum(int num1,int num2){//形参 //数字不明确的时候，就定义在小括号中，并用逗号隔开； int result=num1+num2; System.out.println(result); } }

形参和实参

形参：方法定义中的参数

实参：方法调用中的参数

eg:求长方形的周长

package demo; public class changfangxing { public static void main(String[] args) { getlength(6.6,7.8); } public static void getlength(double chang,double kuan){ double result=(chang+kuan*2); System.out.println(result); } }

eg:求圆的面积

package demo; public class yuan { public static void main(String[] args) { circus(5); } public static void circus(double r){ double result=r*r*3.14; System.out.println(result); } }

带返回值方法的调用

把void改成返回值类型，就是有返回值的方法；

调用的三种方法

最常用的是赋值调用

package demo; public class yuan { public static void main(String[] args) { getsum(5,4,5);//直接调用 double sum=getsum(5,4,5); System.out.println(sum);//赋值调用 System.out.println(getsum(5,4,5));//输出调用 } public static double getsum(int num1,int num2,int num3){ double result=num1+num2+num3; System.out.println(result); return result; } }

在调用处根据方法的结果，去编写另一端代码的时候，需要用到有返回值的方法；

eg:比较两个长方体的面积

package demo; public class yuan { public static void main(String[] args) { int num1=compare(3,4); int num2=compare(5,6); if(num1>num2){ System.out.println("num1"); }else{ System.out.println("num2"); } } public static int compare(int chang,int kuan){ int result=chang*kuan; return result; } }

7数组