javaOCA考点(基础)

在Java中，类是基本的块。类是对象的定义； 对象是类在内存中运行的具体实例。

1.定义变量：

基本格式：

数据类型 变量名 = 值;

常用写法：

int age = 20;           // 整数
double price = 99.9;    // 小数
String name = "张三";    // 字符串
boolean flag = true;    // 布尔值

简单例子：

int num = 10;          // 定义整数变量
String text = "Hello"; // 定义字符串变量
double score = 95.5;   // 定义小数变量

2.定义java类：

基本格式：

public class 类名 {
    // 属性（变量）
    // 方法
}

简单例子：

// 定义学生类
public class Student {
    // 属性
    String name;
    int age;
    
    // 方法
    public void study() {
        System.out.println(name + "在学习");
    }
}

使用类：

Student stu = new Student();  // 创建对象
stu.name = "张三";             // 设置属性
stu.age = 20;
stu.study();                  // 调用方法

3.引用宝

基本格式：

import 包名.类名;      // 引用单个类
import 包名.*;         // 引用包中所有类

常用例子：

import java.util.Scanner;      // 引用Scanner类
import java.util.*;           // 引用util包所有类
import java.time.LocalDate;   // 引用LocalDate类

4.代码示例(前三个总结)：

import java.util.Scanner;  // 第一步：引用包
import java.util.Date;

public class Test {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);  // 第二步：使用
        Date now = new Date();
    }
}

5.属性与方法：

属性（变量）：

public class Person {
    // 属性定义
    String name;     // 姓名
    int age;         // 年龄
    double score;    // 分数
}

方法：

public class Person {
    String name;
    
    // 普通方法
    public void sayHello() {
        System.out.println("你好，" + name);
    }
    
    // 带参数方法
    public void setInfo(String n, int a) {
        name = n;
        age = a;
    }
    
    // 带返回值方法
    public int getAge() {
        return age;
    }
}

使用：

Person p = new Person();
p.name = "张三";      // 设置属性
p.sayHello();        // 调用方法
int a = p.getAge();  // 获取返回值

6. 注释

单行注释， 一般用 "// ... "

多行注释， 一般用 "/* ... */ "

Javadoc 多行注释， 一般用 "/** ... */ "

7.类和文件

一个文件下也可以放多个class， 但是要确保最多只有一个class 为 public class。

基本规则：

一个文件 = 一个公共类
文件名 = 类名.java

例子：

// Student.java
public class Student {  // 公共类名必须与文件名相同
    String name;
    int age;
}

特殊情况：

// Main.java
public class Main {      // 公共类
    // 主方法
    public static void main(String[] args) {
        System.out.println("Hello");
    }
}

class Helper {            // 非公共类（同文件只能有一个公共类）
    void help() {
        System.out.println("帮助");
    }
}

文件结构：

项目文件夹/
├── Main.java          // 文件
└── 其他文件.java

8.Java包和导入

包的作用：组织相关类，避免类名冲突。

定义包：

// Student.java
package com.school;  // 必须第一行

public class Student {
    String name;
}

导入包：

// Main.java
import com.school.Student;  // 导入Student类
import com.school.*;        // 导入school包所有类
import java.util.*;         // 导入java.util包

public class Main {
    public static void main(String[] args) {
        Student stu = new Student();  // 使用导入的类
    }
}

注意：

1.import java.util.Scanner;
2.import java.util.*;

1 和 2 为重复导入， 当class 调用 Scanner 时， 则会调用 1 而不是 l 2， 因为 1 相较于 2 更加具体。

如果当导入的多个包都有此class， Java 会报编译错误，比如：

import java.util.*;
import java.sql.*; 
public class Conflicts {
Date date;
}

为什么编译错误？原因：

import java.util.*;  // 导入util包的所有类（包括Date）
import java.sql.*;  // 导入sql包的所有类（也包括Date）

public class Conflicts {
    Date date;  // 编译器不知道你要用哪个Date！
}

俩个包都有Date：

java.util.Date    - Java自带的时间类
java.sql.Date     - 数据库专用时间类

两个包有同名类时，必须明确告诉Java用哪个，否则它会"不知道选哪个"而报错。

9.创建对象：

基本方法：

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

简单例子：

// 1. 先定义类
class Person {
    String name;
    int age;
}

// 2. 创建对象
public class Main {
    public static void main(String[] args) {
        Person p = new Person();  // 创建Person对象
        p.name = "张三";           // 给属性赋值
        p.age = 20;
    }
}

直接来：

Person p = new Person();  // 创建对象并赋值

9.Java引用类型和基本类型的区别

基本概念：

基本类型 ：直接存储数据，像是一个小盒子，里面直接放着值。

引用类型 ：存储内存地址，像是一张藏宝图，告诉你数据在哪里。

10.基本类型（Primitives）

1.特点：

存储实际的值 ，在栈内存中，有固定大小，有默认值。

2.8种基本类型：

int age = 25;       // 整数
double score = 95.5; // 小数
char grade = 'A';   // 字符
boolean flag = true; // 布尔

类比 ：就像你钱包里直接放着100元现金

2.引用类型（References）

1.特点

存储内存地址 ，在堆内存 中存数据，用 new创建，默认值是 null。

2.常见引用类型：

String name = "张三";           // 字符串
Person p = new Person();       // 对象
int[] nums = {1, 2, 3};        // 数组

类比 ：就像你钱包里放着一张纸条，写着"保险箱密码是123"

3.关键区别

1. 赋值方式：

// 基本类型：复制值
int a = 10;
int b = a;  // b得到10的复制

// 引用类型：复制地址
Person p1 = new Person("张三");
Person p2 = p1;  // p2和p1指向同一个对象

2.修改影响：

int x = 5;
int y = x;
y = 10;  // x还是5，y变成10

Person p1 = new Person("张三");
Person p2 = p1;
p2.name = "李四";  // p1.name也变成"李四"！

解释：p1和p2是同一张"藏宝图"，找到的是同一个宝藏，改一个都会变。

3.比较：

int a = 5, b = 5;
System.out.println(a == b);  // true（比较值）

Person p1 = new Person("张三");
Person p2 = new Person("张三");
System.out.println(p1 == p2);  // false（比较地址）

4.总结：

特点	基本类型	引用类型
存储什么	实际值	内存地址
内存位置	栈	堆（数据在堆，地址在栈）
默认值	0/false	null
创建方式	直接赋值	用new
赋值行为	复制值	复制地址

记住：基本类型是"值本身"，引用类型是"找到值的地址"！

先到这里