Java教程

Java基础知识

本文主要是介绍Java基础知识,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!
  1. 面向过程和面向对象

面向过程性能高,面向对象易维护,易复用,易扩展。

  1. java 特点
  • 面向对象(封装,继承,多态)
  • 平台无关性
  • 安全可靠
  • 支持多线程
  1. JVM:Java 虚拟机,是运行 Java 字节码(.class文件)的虚拟机。

    JDK:Java开发工具包

    JRE:Java运行环境

    关系:JDK包含JRE和JAVA的开发工具

    ​ JRE包含JVM和JAVA的核心类库

    image

  2. JAVA 与C++比较

  • 都是面向对象的语言,都支持封装、继承和多态。
  • Java 不提供指针来直接访问内存,程序内存更加安全
  • Java 的类是单继承的,C++ 支持多重继承;虽然 Java 的类不可以多继承,但是接口可以多继承。
  • Java 有自动内存管理机制,不需要程序员手动释放无用内存。
  1. 重写和重载

重写:子类重新编写父类的方法,方法名相同,参数相同。

重载:方法名相同,参数不同

  1. 面向对象的特点:抽象,封装,继承,多态
  2. String:不可变的 (可变的含义:指针是否指向新的对象)

​ StringBuilder:可变的,线程不安全,可在单线程中使用

​ StringBuffer: 可变的,线程安全,多线程中使用

  1. 自动装箱和拆箱

装箱就是 自动将基本数据类型转换为包装器类型;拆箱就是 自动将包装器类型转换为基本数据类型。

Integer i = 10;  //装箱
int n = i;   //拆箱
  1. 接口和抽象类的区别
  • 接口的方法默认是 public,所有方法在接口中不能有实现,而抽象类可以有非抽象的方法。
  • 一个类可以实现多个接口,但只能实现一个抽象类。
  • 抽象类表示的是,这个对象是什么。接口表示的是,这个对象能做什么。
  • 接口中基本数据类型为static 而抽类象不是的。
  1. 成员变量和局部变量

成员变量是属于类的,而局部变量是在方法中定义的变量或是方法的参数;成员

变量可以被 public,private,static 等修饰符所修饰,而局部变量不能被访问控制修饰符及 static 所

修饰;但是,成员变量和局部变量都能被 fifinal 所修饰。

  1. ==与equals()

== : 它的作用是判断两个对象的地址是不是相等。

equals() : 它的作用也是判断两个对象内容是否相等

  1. hashcode 和equals

两个obj,如果equals()相等,hashCode()一定相等

两个obj,如果hashCode()相等,equals()不一定相等

HashSet 检查重复 :先获取hashcode 如果相等,再用equals() 比较

  1. oracle 查询那些表锁

    select * from v$locked_object a, dba_objects b where b.object_id=a.object_id
    
  2. 值传递(值调用)和引用传递(引用调用)

值传递是对基本型变量而言的,传递的是该变量的一个副本,改变副本不影响原变量. 引用传递一般是对于对象型变量而言的,传递的是该对象地址的一个副本, 并不是原对象本身 ,所以一个方法可以修改引用传递所对应的变量值,而不能修改值传递所对应的变量值。

一般认为,java内的传递都是值传递

  1. 线程和进程

一个进程可以包含多个线程。

进程是程序执行的基本单位,线程是cpu调度的基本单位。
一般来说,
进程是为了程序的并发执行,线程是为了并发的执行程序!

进程是操作系统资源分配的基本单位,而线程是任务调度和执行的基本单位。

线程的状态:

image

影响线程的方法:

image

https://blog.csdn.net/Andya_net/article/details/106206807

image

package com.company;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.*;

public class Mianshi extends  Thread{

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CreateThread createThread = new CreateThread();
        createThread.start();

        NewThread newThread = new NewThread();
        newThread.run();
        Thread thread = new Thread(newThread);
        thread.start();
        
        CreateThreadByOtherWay chy =new CreateThreadByOtherWay();
        chy.CallableThread();

        BasicThreadPool basicThreadPool = new BasicThreadPool();
        basicThreadPool.ThreadPool();

    }


    //继承Thread类
    public static class CreateThread extends Thread{

        @Override
        public void run() {
            System.out.println("通过thread创建了一个线程");
        }
    }

    //实现Runnable接口
    public static class NewThread implements Runnable{
        @Override
        public void run() {
            System.err.println("通过接口Runnable创建线程");
        }
    }

    //通过ExecutorService 和Callable<T>实现有返回值的线程
    public static  class  CreateThreadByOtherWay implements Callable<String> {
        private String num;
        public CreateThreadByOtherWay(String num){
            this.num =num;
        }
        public CreateThreadByOtherWay(){

        }

        @Override
        public String call() throws Exception {
            return num;
        }

        public  void CallableThread () throws ExecutionException, InterruptedException {
            ExecutorService pool = Executors.newFixedThreadPool(5);
            List<Future> list = new ArrayList<>();

            for (int i = 0; i < 10; i++) {
                Callable<String>  chy = new CreateThreadByOtherWay(i+"yyds");
                Future<String> future = pool.submit(chy);
                list.add(future);
            }
            for (Future<String> f:list
            ) {
                System.err.println(f.get());
            }
        }
    }

    //基于线程池创建
    public static class BasicThreadPool {
        public void ThreadPool() {
            ExecutorService threadPool = Executors.newFixedThreadPool(10);
            for (int i = 0; i < 10; i++) {
                threadPool.execute(new Runnable() {
                    @Override
                    public void run() {
                        System.out.println(Thread.currentThread().getName() + " is running !");
                    }
                });
            }
        }
    }
}

  1. final
  • final 修饰的类无法被继承
  • final 修饰的方法无法被重写
  • final 修饰的基本类型变量,一旦在初始化之后便不能更改。
  • final修饰的实例变量一般添加static修饰 变成静态的
  1. 异常处理

image

  • Throwable是所有错误或异常的父类

  • 异常和错误的区别:异常能被程序本身处理,错误是无法处理。

  • Throwable 类常用方法: getMessage():返回异常发生时的详细信息,toString():返回异常发生时的简要信息getLocalizedMessage():返回异常对象的本地化信息,printStackTrace() 在控制台上打印Throwable对象封装的异常信息

  • 异常处理方式:抛出异常、使用try catch finally捕获并处理异常。finally:无论是否捕获或处理异常,fifinally 块里的语句都会被执行。当在 try 块或 catch 块中遇到 return 语句时,fifinally 语句块将在方法返回之前被执行

  • throw和throws的区别:

    位置不同:throws作用在方法上,后面跟着的是异常的类;而throw作用在方法内,后面跟着的是异常的对象

    功能不同: throws用来声明方法在运行过程中可能出现的异常,throw用来抛出封装了异常信息的对象

  • 常见面试题:[https://blog.csdn.net/ThinkWon/article/details/104390689](https://blog.csdn.net/ThinkWon/article/details/104390689

  1. Java序列化是不想序列的变量添加transient关键字修饰,只能修饰变量,不能修饰方法和类

  2. 键盘输入变量的值的两种方式:

方式一:
Scanner input = new Scanner(System.in); 
String s = input.nextLine(); 
input.close();
方式二:
BufferedReader input = new BufferedReader(new InputStreamReader(System.in)); 
String s = input.readLine();    
  1. Java 中的IO流

    image

    Java I0 流的 40 多个类都是从如下 4 个抽象类基类中派生出来的。

    • InputStream/Reader: 所有的输入流的基类,前者是字节输入流,后者是字符输入流。
    • OutputStream/Writer: 所有输出流的基类,前者是字节输出流,后者是字符输出流。

image

  1. 深拷贝和浅拷贝

浅拷贝:对基本数据类型进行值传递,对引用数据类型进行引用传递般的拷贝,此为浅拷贝。

深拷贝:对基本数据类型进行值传递,对引用数据类型,创建一个新的对象,并复制其内容。

  1. 集合和工具类
    image
这篇关于Java基础知识的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!