Java开发基本语法笔记其二

最新推荐文章于 2024-06-06 04:53:51 发布
最新推荐文章于 2024-06-06 04:53:51 发布
阅读量900 收藏 18
点赞数 23
分类专栏： Java开发 文章标签： java 笔记 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52261161/article/details/136938557
版权


知识库…

日志框架

。日志规范接口:Commons Logging，Simple Logging Facade for Java(Slf4j)

Logback日志框架

SpringBoot默认集成Slf4j，可以直接注解Slf4j
三个技术模块
。logback-core：入口，必须有
。logback-classic
。logback-access
😄快速入门：
步骤:
1.新建lib文件夹，把logback需要的jar包导入该文件夹下
logback的jar包
logback-classic-1.2.3.jarlogback-core-1.2.3.jarslf4j-api-1.7.26.jar
2.把logback核心配置文件，拷贝到scr目录下
logback.xml
3.在代码中获取日志对象，使用API方法

private static Logger logger = LoggerFactory.getLogger("类名");
logger.debug("写控制台输出语句")

//API方法
TRACE < DEBUG < INFO < WARN < ERROR级别大小
TRACE：用于追踪程序的详细执行情况，通常用于输出非常详细的调试信息，适用于排查问题时需要更深层次的信息。
DEBUG：用于调试信息，输出一些对调试有帮助的信息，通常在开发和测试阶段使用。
INFO：用于输出一般信息，标识程序运行中的关键事件，以便了解应用程序的整体运行状态。
WARN：用于警告信息，表示潜在的问题，不影响程序继续运行，但可能需要关注。
ERROR：用于错误信息，表示程序发生了可恢复或不可恢复的错误，可能导致程序异常终止。

异常

image.png
😄异常概述：
程序出现不正常情况，导致JVM的非正常停止
😄存在形式：

  1. 已检查异常（Checked Exception）：
    • 这些异常是在编译时强制处理的异常，必须通过捕获或声明抛出来处理。
    • 通常继承自 Exception 类（不是 RuntimeException 类）。
    • 例如：IOException、SQLException。
  2. 未检查异常（Unchecked Exception）：
    • 也称为运行时异常（RuntimeException），是一种不需要显式捕获或声明的异常。
    • 通常继承自 RuntimeException 类。
    • 例如：NullPointerException、ArrayIndexOutOfBoundsException。
  3. 错误（Error）：
    • 表示严重问题，通常是 JVM 自身无法解决的问题。
    • 通常继承自 Error 类。
    • 例如：OutOfMemoryError、StackOverflowError。
  4. 自定义异常：
    • 为了满足特定需求，可以创建自定义异常类。
    • 继承自 Exception 或其子类，根据具体情况选择合适的基类
// 自定义异常类
class 自定义异常类 extends Exception {
    public MyCustomException() {
        super("This is a custom exception");
    }

    public MyCustomException(String message) {
        super(message);
    }
}

// 在代码中抛出自定义异常
class CustomExceptionExample {
    public static void main(String[] args) {
        try {
            // 某些条件下抛出自定义异常
            throw new MyCustomException("Something went wrong");
        } catch (MyCustomException e) {
            System.out.println("Caught custom exception: " + e.getMessage());
        }
    }
}

😄JVM处理异常方法：
打印异常位置原因，JVM停止
😄处理异常：
main()方法中只能用方法二

。自己不处理，交给别人处理
修饰符号 返回类型 方法名（参数类型 参数）throws 异常类1，异常类2{
    
}

面试题：throws和throw的区别：

  1. throws：
    • throws 关键字用于在方法声明中指定可能会抛出的异常类型，表示该方法可能会抛出指定类型的异常。
    • 当一个方法可能会抛出某种异常时，可以使用 throws 关键字将异常类型列在方法签名后面，通知调用者可能需要处理这些异常。
    • throws 是一种声明式的方式，用于告知编译器该方法可能会抛出哪些异常，但实际的异常抛出和处理是在方法内部进行的。
  2. throw：
    • throw 关键字用于手动抛出异常，即在代码块中创建异常对象并将其抛出给调用者或上层方法进行处理。
    • 通过 throw 可以触发异常，并将控制权交给异常处理机制，让程序按照异常处理流程执行。
    • throw 是一个操作符，用于抛出特定的异常实例，可以是 Java 内置异常类或自定义异常类的实例。
 public static void main(String[] args) {
        try {//处理异常
            throwCustomException();
        } catch (CustomException e) {
            System.out.println("Caught custom exception: " + e.getMessage());
        }
    }

    public static void throwCustomException() throws CustomException {
        // 创建自定义异常对象并抛出
        throw new CustomException("This is a custom exception");
    }


try {
    // 可能会引发异常的代码
} catch (ExceptionType1 e1) {//子异常
    // 处理 ExceptionType1 类型的异常
} catch (ExceptionType2 e2) {//父异常，父异常一定在后面
    // 处理 ExceptionType2 类型的异常
} finally {
    // 可选的 finally 块，用于执行无论是否发生异常都需要执行的代码
}

😄Throwable成员方法：

  1. getMessage():
    • 用于获取异常的详细描述信息，通常是异常发生的原因。
  2. printStackTrace():
    • 将异常信息和异常发生时的调用栈信息输出到标准错误流，可用于调试或日志记录。
  3. getCause():
    • 获取导致当前异常的异常原因，即该异常的根本原因。

Lambda表达式

。简化程序中匿名内部类的书写

public class LambdaExample {
    public static void main(String[] args) {
        // 使用Lambda表达式实现Runnable接口
        Runnable runnable = () -> {
            System.out.println("This is a lambda expression");
        };

        // 使用Lambda表达式作为参数传递给Thread构造函数
        Thread thread = new Thread(runnable);
        thread.start();
    }
}

😄Lambda表达式：
只对函数接口进行代码编写
。函数接口:接口中只有一个抽象方法

@FunctionalInterface
public interface MyFunctionInterface {
    void myMethod();
}

。1.匿名内部类基本实现：

public static void main(String[] args) {
        // 使用匿名内部类继承类
        Animal animal = new Animal() {
            @Override
            void sound() {
                System.out.println("Dog barks");
            }
        };

        animal.sound();
    }

。2.用Lambda表达式简化

 public static void main(String[] args) {
        // 使用Lambda表达式继承类
        Animal animal = () -> System.out.println("Dog barks");

        animal.sound();
    }

。3.标准语法:
Lambda表达式的基本语法如下：

Copy Code(parameters) -> expression
或
(parameters) -> { statements; }

其中：

  • parameters：表示Lambda表达式的参数列表，可以是空参数、单个参数或多个参数。如果没有参数，则使用空括号 ()；如果只有一个参数，可以省略参数类型和括号，比如 a -> a*a；如果有多个参数，使用逗号分隔，比如 (a, b) -> a + b。
  • ->：称为箭头符号，用于分隔参数列表和Lambda表达式的主体。
  • expression：表示Lambda表达式的返回值，可以是一个表达式。
  • {}：用于定义多行代码块，如果Lambda表达式包含多条语句，使用这对大括号 {} 将语句包裹起来。

下面是一些Lambda表达式的示例：

  1. 无参数的Lambda表达式：
CodeRunnable runnable = () -> System.out.println("Hello, Lambda!");
  1. 单个参数的Lambda表达式：
CodeConsumer<String> consumer = message -> System.out.println("Message: " + message);
  1. 多个参数的Lambda表达式：
CodeComparator<Integer> comparator = (a, b) -> Integer.compare(a, b);
  1. 包含多条语句的Lambda表达式：
CodeFunction<Integer, Integer> square = n -> {
    int result = n * n;
    return result;
};

。4.匿名内部类和Lambda表达式的区别:
匿名内部类：可以是接口，抽象类，还可以是具体类，产生一个单独的.class字节码文件
Lambda表达式: 只能是函数接口,编译时字节码动态生成

Stream流

😄作用:
针对集合功能简化开发
😄常用功能及特点：

  1. 惰性求值：
    • Stream 是惰性求值的，只有当终端操作被调用时才会执行中间操作，这样可以提高效率。
  2. 流水线：
    • 可以将多个中间操作和一个终端操作连接起来形成流水线，以便高效地对数据进行处理。
  3. 函数式编程：
    • Stream API 鼓励使用函数式编程的思想，通过Lambda表达式来传递操作，使代码更简洁、易读。
  4. 操作步骤：
    • 流的创建
    • Stream的操作可以分为中间操作（Intermediate Operations）和终端操作（Terminal Operations）两类。
      • 中间操作：如 filter、map、sorted 等，用于对数据进行处理和转换。
      • 终端操作：如 forEach、collect、reduce 等，用于触发流的计算并生成最终结果。
  5. 示例操作：
  • filter: 过滤符合条件的元素。
  • map: 对每个元素进行操作/转换。
  • forEach: 对每个元素执行操作。
  • collect: 将流元素收集到集合中。
  • reduce: 对流中的元素进行累积操作。
  • distinct:去重
  • limit：截取参数个数

😄使用:可以用Lambda简化

  1. 创建流对象

image.png2. 中间操作：
filter：过滤元素。

Codestream.filter(e -> e.startsWith("a"))//过滤以a开始的字符串

map：对每个元素进行操作/转换。

Codestream.map(user -> new SuperMan(user.getName()))

sorted：排序元素。

Codestream.sorted()
  1. 终端操作：使用后流就关闭了

forEach：对每个元素执行操作。

Codestream.forEach(System.out::println)

collect：将流元素收集到集合中。

CodeList<String> resultList = stream.collect(Collectors.toList())

reduce：对流中的元素进行累积操作。

CodeOptional<String> result = stream.reduce((s1, s2) -> s1 + s2)

count：返回流中元素的数量。

Codelong count = stream.count()
  1. 流的收集：把流处理过后的数据返回给一个集合
//将流中的元素收集到一个List集合中
List<String> list = stream.collect(Collectors.toList());
//将流中的元素收集到一个Set集合中
Set<String> set = stream.collect(Collectors.toSet());
//收集为指定类型的集合
LinkedList<String> linkedList = stream.collect(Collectors.toCollection(LinkedList::new));
//收集为映射
Map<Integer, String> map = 
stream.collect(Collectors.toMap(Function key ,Function value));

Optional类

😄用处:
简化非空操作
😄常用API：

orElse：
T orElse(T other)
如果 Optional 对象中包含值，则返回该值，否则返回指定的默认值 other。

ofNullable：
static <T> Optional<T> ofNullable(T value)
创建一个包含指定值的 Optional 对象，该值可以为空。

线程

😄什么是线程：
简单来说，一个进程可以包含多个线程，可以并发地执行不同的任务。在操作系统中，每个进程都有自己的地址空间、资源和执行状态，而线程是进程中的实际执行单位，它共享进程的资源。多个线程可以共享相同的内存区域，这使得线程之间更容易进行数据共享和通信，也提高了程序的运行效率。

线程实现

😄线程的使用：
使用 Thread 类创建线程：

  1. 创建 Thread 子类：创建一个继承自 Thread 类的子类，并重写 run() 方法，该方法包含线程的执行逻辑。
Codeclass MyThread extends Thread {
    public void run() {
        // 线程执行的逻辑
        System.out.println("Hello, I am a thread!");
    }
}
  1. 实例化线程对象：实例化 Thread 子类的对象。
CodeMyThread myThread = new MyThread();
  1. 启动线程：调用线程对象的 start() 方法启动线程的执行。
CodemyThread.start();

使用 Runnable 接口创建线程：

  1. 创建实现 Runnable 接口的类：创建一个实现 Runnable 接口的类，并实现 run() 方法。
Codeclass MyRunnable implements Runnable {
    public void run() {
        // 线程执行的逻辑
        System.out.println("Hello, I am a thread!");
    }
}
  1. 实例化线程对象：创建 Runnable 对象，并将其作为参数传递给 Thread 构造方法。
CodeMyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
  1. 启动线程：调用线程对象的 start() 方法启动线程的执行。
Codethread.start();

线程的常用方法：

  • start()：启动线程，使其进入就绪状态并开始执行。
  • run()：线程的执行逻辑，需要在子类中重写。
  • sleep(long milliseconds)：使当前线程暂停执行指定的毫秒数。
  • join()：等待线程终止。
  • interrupt()：中断线程的执行。

注意事项：

  • 线程的启动是通过调用 start() 方法而不是 run() 方法。
  • 线程共享数据时需要注意线程安全性，避免出现数据竞争和并发问题。
  • 确保合理地管理线程的生命周期，避免资源泄露和性能问题。

线程安全

😄线程安全问题:多个线程对同一个数据进行操作
常见的线程安全问题包括：

  1. 数据竞争（Race Condition）：多个线程同时对共享数据进行读写操作，导致数据的最终状态不确定或错误。
  2. 死锁（Deadlock）：两个或多个线程因为相互持有对方所需的资源而无法继续执行的状态。
  3. 活锁（Livelock）：线程在互相响应对方的动作而无法继续执行的状态，类似于死锁但是线程仍然在不断地改变状态。
  4. 并发修改异常（Concurrent Modification Exception）：在迭代集合的过程中，同时对集合进行修改导致的异常。

线程安全解决方案：

  1. 加锁机制：通过使用 synchronized 关键字或 Lock 接口等机制，在关键代码段内部对共享资源进行加锁，使得同一时刻只有一个线程可以访问共享资源，从而避免数据竞争。
  2. 使用线程安全的数据结构：例如 ConcurrentHashMap、CopyOnWriteArrayList 等，这些数据结构内部实现了对共享资源的安全访问。
  3. 原子操作：使用原子操作类（Atomic 类）来进行原子性操作，保证多个线程对共享变量的操作是原子性的。
  4. 避免不必要的共享：尽量避免多个线程对同一份数据进行并发访问，可以通过拷贝、副本等方式减少共享数据的访问。
  5. 使用线程安全的设计模式：如单例模式中的双重检查锁定等，确保在多线程环境下单例对象的正确创建和访问。
  6. 并发工具类的使用：Java 提供了诸如 CountDownLatch、Semaphore、CyclicBarrier 等并发工具类，可以帮助开发人员更安全地管理多线程之间的协作和同步。

😄代码实现：

//方法一。同步代码块
synchronized(任意对象){
    共享的代码块
}
//方法二。同步方法
 public synchronized void increment() {
        count++;
        System.out.println("Incremented: " + count);
 }
  Thread thread1 = new Thread(() -> counter.increment());
//方法三。Lock锁实现线程同步
//Lock是接口，不能实例化，采用实现类，ReentrantLock来实例化
//void lock():获得锁，void unlock():释放锁
Lock l = new ReentrantLock();
l.lock();//上锁
l.unlock();//解锁

线程通讯

😄什么是线程通讯：
在多线程编程中，线程通讯是指多个线程之间通过共享变量或其他机制来实现信息交换和协作的过程。线程通讯常用于实现线程之间的同步和协作，以达到某种共同的目标。以下是一些常见的线程通讯方式

。等待
wait();//无限等待，其他线程唤醒
wait(long 毫秒);//计时等待，时间到了，自己醒来
。唤醒
void notify();//随机唤醒此对象监视器上等待的单线程
void notifyAll();//唤醒所有进程
不会导致当前线程释放掉锁资源

😄注意事项:
wait()和notify()都必须绑定在对象锁上

Object lock = new Object();

lock.wait();
lock.notify();

线程池

主要优点：

  1. 降低资源消耗：线程池可以控制并发线程的数量，避免因为创建过多线程而导致系统资源耗尽。
  2. 提高响应速度：由于线程池中的线程已经预先创建好，当任务到达时可以立即执行，减少了任务等待的时间。
  3. 提高性能：通过重复利用线程，可以减少线程的创建和销毁开销，从而提高系统的整体性能。
  4. 可以灵活管理线程：线程池可以根据实际需求调整线程数量，动态适应不同的场景。

需要考虑：

  1. 线程池大小：线程池应该设定合适的线程数量，既不能过多导致资源浪费，也不能过少影响任务处理效率。
  2. 任务队列：线程池通常会有一个任务队列，用于存放待执行的任务，线程会从队列中取出任务并执行。
  3. 线程池类型：不同的编程语言或框架可能提供不同类型的线程池，如固定大小线程池、可缩放线程池等，根据实际需求选择合适的类型。

文件处理


打开指定文件

  1. 打开应用程序
Runtime.getRuntime().exec(路径)
  1. 打开文件和文件夹
 runtime.getRuntime().exec("cmd /c start " + file.getAbsolutePath());
  1. 实例
public static void searchFile(File dir,String filename) throws IOException {
    if(dir == null || !dir.exists() || dir.isFile()){
        return;
    }
   File []files =  dir.listFiles();
    if(files != null && files.length > 0){
        for (File file : files) {
            if(file.isFile()){
                if(file.getName().contains(filename)){
                    System.out.println("找到了");
                    Runtime runtime = Runtime.getRuntime();
                    runtime.getRuntime().exec("cmd /c start " + file.getAbsolutePath());
                }else{
                    searchFile(file,filename);
                }
            }
        }
}

删除文件

public static void deleteDir(File dir){
    if(dir == null || !dir.exists()){//为空或不存在
        return;
    }
    if(dir.isFile()){//是文件
        dir.delete();
        return;
    }
    File []files = dir.listFiles();
    for (File file : files) {//遍历一级文件
        if(file.isFile()){
            file.delete();
        }else{
            deleteDir(file);
        }
    }
}

读取文件

FileInputStream

文件读入程序，读一个字节

public static void main(String[] args) throws IOException {
    /*
    1.读过之后，is就不再有该字符
     */
    InputStream is =  new FileInputStream("..\\demon\\aa.txt");//输入流管道
    //读第一个字节;
    int b = is.read();
    System.out.println(b);//-1表示没有数据
    //一次读多个
    byte []butter = new byte[3];
    is.read(butter);
    System.out.println(new String(butter));
    //读所有字节
    byte []bu = is.readAllBytes();
    System.out.println(new String(bu));
    is.close();//流必须关闭
}

FileReader

读取一个字符，可以读汉字

BufferedInputStream

使用的原因:自带8kb的缓冲池，提高性能

InputStream re = new FileInputStream("..\\demon\\aa.txt");
InputStream res = new BufferedInputStream(re);
InputStream ress = new BufferedInputStream(re , 8192 * 2);//扩大缓冲

BufferedReader

新增功能
res.readLine();//读取一行

写入文件

FileOutputStream

程序写入文件，写一个字节

public static void main(String[] args) throws IOException {
   FileOutputStream op = new FileOutputStream("..\\demon\\aa.txt");//覆盖数据
    FileOutputStream op1= new FileOutputStream("..\\demon\\aa.txt",true);//在文件后加数据
   //写字节,只能写一个
    op.write(97);
    op.write('9');
  //写多个数据
  byte[]bytes = "我带你".getBytes();
  op.write(bytes);
  //换行
    op.write("\r\n".getBytes());
    op.close();
}

FileWrite

写一个字符，可以是汉字

BufferedOutputStream

BufferedWrite

新增功能
res.nextLine();//换行

释放资源

try-catch-finally

  1. 类代码
try{
    System.out.println(10 / 2);
}catch (Exception e){
    e.printStackTrace();
}finally {
    /*
    注:
    1.先跑的finally，然后在运行try中，所以finally最好不要return
    2.除非jvm结束，finally都要跑一次
    3.finally可以进行资源释放
     */
    System.out.println("finally里的东西至少跑一次");
}
  1. 实例
public static void main(String[] args) throws IOException {
    OutputStream op = null;//注意OutputStream的作用域
    try {
        op = new FileOutputStream("..\\demon\\aa.txt");
    } catch (IOException e) {
        throw new RuntimeException(e);
    } finally {
        op.close();//关闭流才能刷数据
    }
}

try-with-resource

  1. 类代码
try (//流的定义,会自动关闭){
} catch (IOException e) {
    throw new RuntimeException(e);
}
  1. 实例
try (OutputStream op = new FileOutputStream("..\\demon\\aa.txt");){
} catch (IOException e) {
    throw new RuntimeException(e);
}

文件乱码处理

InputStreamReader

控制按什么类型字符读取

try (
        InputStream is = new FileInputStream("..\\demon\\aa.txt");
        //把原始的按照GBK转换成字符输入流,把GBK转成当前所需的UTF-8
        Reader isr = new InputStreamReader(is,"GBK");
        BufferedReader br = new BufferedReader(isr);
) {
    String line;
    while((line = br.readLine()) != null){
        System.out.println(line);
    }
}

OutputStreamWriter

try (
        OutputStream is = new FileOutputStream("..\\demon\\aa.txt");
        //把原始的UTF-8转成GBK,写入aa.txt
        Writer isr = new OutputStreamWriter(is,"GBK");
        BufferedWriter br = new BufferedWriter(isr);
) {
   br.write("我是中国人");
   br.newLine();
}

打印数据

打印什么就写什么，可以取代写入流

数据输出

特殊文件

properties文件

  1. 内容

主要是用户信息， 一些属性

  1. 读取

采用键值对来读取

 public static void main(String[] args) throws IOException {
        //创建一个properties对象，类似于Map(键值对集合)
        Properties properties = new Properties();
        System.out.println(properties);

        properties.load(new FileReader("..\\demon\\src\\user.properties"));
        System.out.println(properties);
    }
  1. 写入

public static void main(String[] args) throws IOException {
    Properties properties = new Properties();
    properties.setProperty("bb","djska");
    properties.setProperty("aa","adsd");
    
    properties.store(new FileWriter("..\\demon\\src\\user.properties"),"写入注解");
}

XML文件

可扩展标记语言

  1. 作用

存储复杂的数据结构
用来做配置文件

  1. 读取

Dom4J

Tag_B
关注
  • 23
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
学习Java基本语法的基本笔记.rar
06-27
一、特性和优势 ...二、JDK、JRE、 JVM JDK: Java Development Kit JRE: Java Runtime Environment JVM: Java Virtual Machine JDK = JRE + 开发工具集(如Javac编译工具等) JRE = JVM + Java SE 标准类库
Java基础最全笔记文档
07-29
2. Java基础语法、类型转换、运算符、Scanner 3. 分支结构、循环结构、随机数 4. 数组详解、Debug工具使用 5. 方法详解 6. 编程思维案例 7. 面向对象基础 8. 常用API 9. 综合项目实战 Java加强篇包括： 1. static、...
关于JAVA的一些基本内容-笔记
私信up主，有惊喜
09-10 9万+
此外，我们还将分析Java在企业级应用开发中的未来趋势和发展方向，以及Java和其他编程语言（如Go和Rust）之间的竞争和比较。本节将介绍Java的未来发展趋势和新特性，包括Java 9模块化系统、Java 10局部变量类型推断、Java 11的新特性等，并给出Java在云计算和人工智能领域的应用和竞争情况，同时也会对其他编程语言的发展进行分析和比较。本节将介绍Java在企业级应用开发中的基本概念、技术架构和常用框架，包括EJB、Spring企业版、Java EE等，并给出一些企业级应用开发的应用案例。
Java基本语法
微风洋洋的博客
01-23 3625
今天这篇文章向你们详细的介绍了Java基本语法，包括关键字、标识符、变量、基本数据类型及其间的转换、各种编码和各种运算符，全程干货，尽情享用。接下来会陆续发布后面深入的内容，希望你们持续关注。感恩！
java最简单最全入门基础笔记(不简单，不全你打我)
热门推荐
javaboy_yl
11-11 13万+
刚开始学习java的时候，可能是一头雾水，不知道从何学起，这里跟大家分享一下!(仅仅只供初级学者学习，大佬勿喷) 一、初始java 1.生活中的程序： 从起床到教室上课的过程 穿衣打扮》起床》洗漱》出宿舍》》吃早餐》到教室 按照特定的顺序去完成某一件事的过程我们叫做生活中的程序 2.计算机中的程序: 一组有序指令的集合,需要和计算机交流就要使用计算机语言，java就是计算机语言的一种 3.java...
Java基础学习笔记 —— 基础语法篇
小熊的学习记录
08-15 227
一些关于javase的基础语法
Java 语法学习笔记（一）
MLee 的博客
01-14 520
Java 语法学习笔记（一） Java 基础语法 文章目录Java 语法学习笔记（一）参考教程介绍基础语法类和对象源文件声明规则基本类型内置数据类型引用类型Java 常量Java 变量类型局部变量实例变量类变量（静态变量）Java 修饰符static 修饰符final 修饰符abstract 修饰符synchronized 修饰符transient 修饰符volatile 修饰符Java 运算符...
Java学习笔记：类的基本语法
薛定谔的猫
01-28 833
1、给大家说过我想“不管getter/setter”，直接用public的私有变量，但是发现这个getter/setter还是有必要讲的，也没有过于麻烦。 2、age、name这些成员变量，就是类的对象的“状态”/属性，setAge、sayHello等方法就是Person类的对象能够接收的“消息”。其实完全可以把age、name做成public，然后去掉setAge等方法，但是使用setAge方法后，可以做业务逻辑控制，比如“拒绝非法值”。 3、初学者完全弄明白不可能，明白一个大概即可。 1、本来...
笔记01-Java基础语法
terence的博客
06-27 4万+
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
JAVA学习笔记-JAVA基础语法-DAY04
最新发布
zzq393109417的博客
06-06 120
IDEA是一个专门针对Java的集成开发工具(IDE)，由Java语言编写。所以，需要有JRE运行环境并配置好环境变量。它可以极大地提升我们的开发效率。可以自动编译，检查错误。在公司中，使用的就是IDEA进行开发。
Java 笔记 01：Java 概述，MarkDown 常用语法整理
默默找寻着，那于世而存的蛛丝马迹。
04-18 1381
本文介绍了计算机和 Java 相关知识，整理了 MarkDown 笔记的常用语法，从零基础开始，走进 Java 的世界。
Java基础语法学习笔记（day01）
qq_43470538的博客
06-02 124
javase java2ee 笔记
07-04
Java开发环境搭建 Java是一门编程语言，是用来编写软件的。QQ、迅雷、淘宝、京东等等这些常用软件都可以用Java来编写。 其实，Java最擅长的是编写如下类型的软件： 1、互联网：电商、P2P 2、企业级应用：ERP、CRM、...
Java开发详解.zip
09-02
010102_【第1章：JAVA概述及开发环境搭建】_Java开发环境搭建笔记.pdf 010201_【第2章：简单Java程序】_简单Java程序笔记.pdf 010301_【第3章：Java基础程序设计】_Java数据类型笔记.pdf 010302_【第3章：Java基础...
狂神说上课笔记未删减 Java基础到技术升级
08-09
2、JavaSE：基础语法 3、JavaSE：流程控制 4、JavaSE：方法 5、JavaSE：数组 6、JavaSE：面向对象 7、JavaSE：异常机制 8、JavaSE：常用类 9、JavaSE：集合框架 10、JavaSE：IO流 11、JavaSE：多线程 12、...
进阶2 探索图形化编程：扩展图形组件与切片开发的魅力
优树搭的博客
05-30 1587
当这些切片成功地通过图形程序串联起来后，在后续进行程序升级或维护时，大家会惊喜地发现，图形程序就如同清晰的路标一般，可以非常便捷地通过图形程序准确地定位到相关切片，并对这些切片进行在线查看、编辑和执行等操作。而且，这些切片的代码长度通常不会太长，相比传统开发的代码，阅读起来要容易得多，这无疑会给系统后续的工作带来极大的便利。
JavaScript第九讲：BOM编程
星途码客的博客
06-04 1067
今天星途给大家带来JavaScript倒数第二部分知识：BOM编程，希望对码客们有帮助。
设计模式之装饰器模式
丿微风乍起的博客
06-05 650
装饰器模式是一种结构型设计模式，它允许我们在不改变原有对象结构的情况下，动态地给对象增加一些职责（即增加其额外功能）。其核心在于通过组合而非继承的方式来扩展对象的功能。Component: 这是抽象组件接口，所有的具体组件和装饰器都必须实现这个接口。Concrete Component: 具体组件，这是我们要装饰的基本对象，它实现了Component接口。Decorator: 抽象装饰器，也是实现Component接口的，它包含一个对Component类型的引用，通常在构造函数中初始化。
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
Itmastergo的博客
05-31 1046
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
java后端开发学习笔记
10-20
2.Java基础：学习Java语言的基础知识，包括语法、面向对象编程、异常处理、集合框架等。 3.Java Web开发：学习Java Web开发的相关知识，包括Servlet、JSP、Spring MVC、Struts2等。 4.数据库开发：学习数据库的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Tag_B

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值