Java基础（一）---面试笔记

于 2025-04-14 20:16:18 发布
阅读量830 收藏 25
点赞数 23
文章标签： 面试 笔记 职场和发展
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_62054791/article/details/147088958
版权

一、ArrayList和LinkList的区别

  1. ArrayList基于动态数组实现，默认初始容量为10，档元素数量超过当前容量会扩容，实现长度可变的数组，适合随机访问，对于遍历元素和随机访问元素的场景，使用Arr比较好ayList性能
  2. LinkList基于双向链表实现，采用链表来存储，当插入、删除操作频繁时，可使用LinkedList来提高效率，还额外提供对头部和尾部元素进行添加和删除操作的方法
  3. 既综上所述，Arraylist适合遍历元素和随机访问场景，LinedList适合插入删除频繁的操作

二、单例模式和多例模式

  1. 单例模式就是所有的请求都用一个对象来处理，在通常的SSH中，单例在Spring中是默认的
    单例其实就在内存中该对象只有一个内存地址，无论多少个线程访问对象，都是一个内存地址
     创建单例模式 
    public class SingleTon {
    private static SingleTon singleTon;

    /**
     * 使用Private关键词将SingleTon的构造函数私有化-->目的是为了禁止外部创建SingleTon的实例
     */
    private SingleTon(){};

    /**
     * 给外部提高getInstance（）静态方法用于获取SingeTon的实例
     * @return
     */
    public synchronized static SingleTon getInstance(){
        /**
         * 判断当前缓存实例是否为空，若为空就创建一个新的实例。否则直接返回缓存实例即可
         */
        if(singleTon==null){
            singleTon=new SingleTon();
        }
        return singleTon;
    }
    public void  singleTonTest(){
        System.out.println("singleTest is called");
    }

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
    public void is_Test() {
        System.out.println("this is name"+getName());
    }
}

    测试单例模式
     

    public class A_单例模式 {
    public static void main(String[] args) {
        SingleTon singleTon=SingleTon.getInstance();
        singleTon.setName("xuhanxin");
        SingleTon singleTon1=SingleTon.getInstance();
        singleTon1.setName("Cindy");
        singleTon.is_Test();
        singleTon1.is_Test();
        if(singleTon==singleTon1){
            System.out.println("创建同一个实例");
        }else{
            System.out.println("创建的不是同一个实例");
        }
    }
}

    单例模式分为饿汉式和懒汉式，
    饿汉是就是类一旦加载就把单例初始化完成，保证getInstace的时候，单例就已经存在
    懒汉是比较懒，只有当调用getInstance的时候，才回去初始化这个单例

  2. 多例模式
    在通用SSH中，产生多例模式，则在配置文件中的bean中添加scope=“prototype”
    多例模式可以有多个实例，多例类必须能够自我创建并管理自己的实例，并且向外界提高自己的实例

三、线程和进程 

1：进程

  1. 进程：进程是一个具有一定独立功能的程序在一个数据集合上一次动态执行的过程。进程是一个正在执行的程序的实例，包括程序计数器、寄存器和程序变量的当前值
    特征：
      （1）：进程依赖于程序运行而存在，进程是动态的，程序是静态的
      （2）：进程是操作系统进行资源分配和调度的一个独立单位（CPU除外，线程是处理器任务调度和执行的基本单位）
     （3）：某个进程拥有独立的地址空间。进程之间的地址空间是隔离的，互不影响

2：线程 

  1.  

3：区别和包含关系 

  1. 本质区别：进程是操作系统资源分配的基本单位，线程是处理器任务调度和执行的基本单位
  2. 包含关系：一个进程至少有一个线程，线程是进程的一部分，所以线程也被称为轻权进程和轻量级进程 

四、封装、继承和多态 

1：封装

  1. 定义：指的是将对象的属性和实现细节隐藏起来，仅对外公开接口，从而控制程序中属性的读取和修改的访问级别

2：继承 

  1.  定义：它允许一个类继承另一个类的属性和方法
  2. 作用：
    （1）：将方法复用
    （2）：将类与类之间产生关系
    父类
  3. public class Animal {
    private String name;
    private int age;
    private String sex;

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getSex() {
        return sex;
    }

    public Animal(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }

    public void is_age(String name,int age){
        System.out.println(name+"今年是"+age);
    }
}

    子类

    public class Dog extends Animal{

    public Dog(String name, int age, String sex) {
        super(name, age, sex);
    }
    public void is_sex(String name,String sex){
        System.out.println(name+"是"+sex);
    }
}

    Test
     

    public class Test {
    public static void main(String[] args) {
        Dog dog=new Dog("小狗",20,"男");
        dog.is_sex(dog.getName(), dog.getSex());
        dog.is_age(dog.getName(), dog.getAge());
    }
}

3：多态 

  1. 定义： 多种形态，具体点就是去完成某个行为，当不同的对象去完成时会产生出不同的状态，既同一引用类型，使用不同实例而执行不同的操作
  2. 实现多态的两个要素
    （1）：子类重写父类
    （2）：父类引用子类对象
    （3）：如果子类重写父类的方法，真正执行的是子类重写的方法，如果子类没有重写父类的方法，执行的是父类的方法
  3. public class Dog extends Animal{
    private String name;
    private int age;
    private String sex;

    public Dog(String name, int age, String sex) {
        super(name, age, sex);
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }


    public void is_eat(String name){
        System.out.println("小狗"+getName()+"正在坑骨头");
    }
}
    public class Penguin extends Animal{
    private String name;
    private int age;
    private String sex;

    public Penguin(String name, int age, String sex) {
        super(name, age, sex);
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Penguin{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
    public void is_eat(String name){
        System.out.println("企鹅"+name+"正在吃冰块");
    }
}

    public class Animal {
    private String name;
    private int age;
    private String sex;


    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getSex() {
        return sex;
    }

    public Animal(String name, int age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "Animal{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }

    public void is_eat(String name){
        System.out.println("小狗"+name+"正在坑骨头");
    }
    public void is_Age(Animal animal){
        if(animal instanceof Dog){
            if(animal.getAge()>10){
                System.out.println("小狗的年龄为"+animal.getAge()+"还未成年");
            }else{
                System.out.println("小狗已经成年了");
            }
        }
        if(animal instanceof Penguin){
            if(animal.getAge()>10){
                System.out.println("企鹅的年龄为"+animal.getAge()+"还未成年");
            }else{
                System.out.println("企鹅已经成年了");
            }
        }
    }
}

    public class Test {
    public static void main(String[] args) {
        Animal animal=new Dog("小狗",13,"男");
        animal.is_Age(animal);
        Animal animal1=new Penguin("企鹅",15,"女");
        animal1.is_Age(animal1);
    }

}

五、Mysql基础

1、定义

        mysql默认的存储引擎是InnoDB存储引擎

 2、创建表、数据库

#创建数据库并指定编码为utf-8
CREATE DATABASE shixun20240507 character set utf8;


#切换到指定数据库
use shixun;

#创建表
-- primary key 主键
-- auto_increment 自增
-- comment 别名(既可用'',也可用"")

CREATE table student(
		id int PRIMARY KEY auto_increment,
		stu_name VARCHAR(200) COMMENT '学生姓名',
		stu_age int COMMENT	'学生年龄',
		stu_sex VARCHAR(10) COMMENT '学生性别',
		stu_number varchar(100) COMMENT "学号"
) COMMENT '学生信息';

3、增删改查

1： 查 select

-- 查询语句
-- SELECT * FROM 表名
SELECT * from  student;
SELECT id,stu_name from student;

2：删 drop


#删除
-- 删除表
-- drop  table 表名
-- 删除库
-- drop DATABASE 数据库名
drop TABLE student;
drop database shixun;

 

六、drop、delete、truncate的区别

1：drop

        指丢弃数据，直接将表都删除掉，在删除表的时候使用

2：truncate

        truncate table 表名 ，指清空数据，只删除表内数据，不删除表，再插入数据的时候id自增长又从1开始，在清空表中数据的时候使用

3：delete

        delete from 表名 where 列名=值，指删除某一行的数据，若不加where子句和truncate table 表名作用类似

  1.  综上，delete 和truncate、drop均有删除表中数据的作用，delete不加where子句时和truncate效果相同，执行drop语句时，此表的结构也会删除
  2. truncate和delete属于DDL语言（数据定义语言），delete属于DML语言（数据库操作语言）

七、continue、break、return的区别 

  1. continue指跳出当前的这一次循环，继续下一次循环
  2. break指的是跳出整个循环
  3. 跳出所在方法，结束该方法的运行

八、接口和抽象类的区别

        共同点：

         都不能直接被实例化，只能被继承抽象类或实现接口后才可被实例化，都含有抽象方法，抽象方法内没有方法体，需要在子类或实现类内实现

        差异点：

  1.         一个类只能继承一个抽象类，但一个类可以实现多个接口
  2. 接口内的成员变量使用private static final 修饰不能被修改且必须有修饰符，抽象类可以使用任一修饰符
  3. 接口内均是抽象方法，抽象类内含有抽象方法和非抽象方法，抽象方法不含有方法体，必须在子类实现，非抽象方法还有方法体可以在抽象类或子类中实现

九、 浅拷贝和深拷贝

1：浅拷贝

        浅拷贝会在堆上复制内部对象的引用地址，也就是说和拷贝对象和原对象共用同一个内部对象

2：深拷贝

        深拷贝会直接复制整个对象，包括这个对象包括的内部对象

十、==和equals

1：==

        对于基本数据类型来说，==比较的是数据的值

        对于引用数据类型来说，==比较的是内存地址

2：equals

        equals不能比较基本数据类型，只能比较引用数据类型，当equals没有被重写时，等价于通过“==”比较两个对象

        String的equals和Object的equals方法，String的equals方法被重写过，比较的是String字符串的值，Object的equals方法比较的是内存地址

3：hashcode

        equals判断两个对象是相等的，则hashcode必然相等

        hashcode相同的两个对象，他们不一定是相等的

十一、String、StringBuffer、StringBuilder

1：String

        String使用final来修饰字符数据且为私有，因此长度是不可变的，安全，操作少量的数据使用String

2：StringBuffer

        StringBuffer的长度是可变的，方法使用同步锁修饰，比StringBuilder安全，多线程操作字符串缓冲区下操作大量数据的使用StringBuffer

3：StringBuilder

        StringBuilder长度也是可变的，但没有使用同步锁修饰，单线程且操作字符串缓冲区下操作大量数据使用StringBuilder

        （“+”和StringBuilder的区别，字符串使用“+”内部逻辑为调用StringBuilder内部的append方法后使用toString得到，使用循环时调用“+”会出现明显的错误为StringBuilder不会复用，会大量创建多个StringBuilder对象）

        

                        

         

 

         

   

Master878
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值