最新Android学习-JAVA基础 (一)，掌门一对一java面试流程

总结

三个工作日收到了offer，头条面试体验还是很棒的，这次的头条面试好像每面技术都问了我算法，然后就是中间件、MySQL、Redis、Kafka、网络等等。

• 第一个是算法

关于算法，我觉得最好的是刷题，作死的刷的，多做多练习，加上自己的理解，还是比较容易拿下的。

而且，我貌似是将《算法刷题LeetCode中文版》、《算法的乐趣》大概都过了一遍，尤其是这本

《算法刷题LeetCode中文版》总共有15个章节：编程技巧、线性表、字符串、栈和队列、树、排序、查找、暴力枚举法、广度优先搜索、深度优先搜索、分治法、贪心法、动态规划、图、细节实现题

《算法的乐趣》共有23个章节：

• 第二个是Redis、MySQL、kafka（给大家看下我都有哪些复习笔记）

基本上都是面试真题解析、笔记和学习大纲图，感觉复习也就需要这些吧（个人意见）

• 第三个是网络（给大家看一本我之前得到的《JAVA核心知识整理》包括30个章节分类，这本283页的JAVA核心知识整理还是很不错的，一次性总结了30个分享的大知识点）

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

3.如果类中有带参构造方法，你又想使用无参构造方法，必须吧无参的写出来

4.在构造方法中调用其他构造方法时，要有出口，用this（“”）调用，该语句必须在第一句

5.一个类中有相同的方法名不同的参数（包含不同类型（一个int的，一个string的）的参数和不同个数的参数），叫重载

public Result(){



    }

    public Result(int a){



    }

    public Result(String a){



    }

    public Result(String a,int b){



    }  

10.String类原理分析

1.赋值：

1.//String的两种赋值方式

String a = “大雄”//该方式可能不需要创建对象，如果常量池中已经存在的话

String a1=a;（推荐）

system.out.print(a==a1);返回true///判断两个内存地址是否相同

String a = new A(“大雄”);//该方式最少需要创建一个对象（当常量池中存在的时候），

如果常量池中不存在，

那么常量池中创建一个，堆内存中创建一个（即2个对象）

String a = new String(“stringg”)

创建了两个对象，一个是在常量池中，一个是在堆内存中，

常量池的为”stringg”;堆内存中为new String();

//字符串直接赋值时，要看值咋编译器能不能确定，如果能确定，就会在常量池中创建，并指向该对象；如果不能，将在运行期的时候在堆内存中创建对象

String a= “a”;//在当前编译器可以确定，所以在常量池

String a1 = a+1;//因为a是一个变量，1是常量，变量的值是在运行期（当前是编译期）才能确定,会在堆内存创建，所以a1的值不能确定（如果想第2中方法中吧String a变成final就可以确定了，因为final代表是一个常量）

String b= a1;

System.out.println(a1==b) 返回false

final String c = “c”//final表示定义一个常量

String c1 = c+1;//因为c和1都是常量，那么此时c1的值可以的编译期确定

String b1 = “c1”

System.out.println(c1==b1);返回true//都是常量池中的对象

public static getd(){//方法调用在运行期才能返回结果

return “d”;

}

final String d=getd();

final String d1 = d+1;

final String e = “d1”

System.out.println(d1==e) 返回false,原因是d的值在编译期不能被确定（方法调用在运行期才能返回结果），所以不相等

Sting a = “a”+1;

String b = “a1”;

System.out.println(a==b)返回true，因为ab都是常量，所以编译器可以确定值

与方法1不同的是方法1的String a1 = a+1; 因为a没有final 所以是一个变量

11.String的常用方法

String a = “aljfdljflsfljslfjsf”;

char c = a.charAt(0); c = a;

char cs[] = s.toCharArray();//转换成字符数组

Sting s1 = new String(cs,0,5)//截取字符数组，从0开始到5

s1 = “aijfd”

判断是否以什么字符串开头，结尾

//是否与字符串开头

if(s.startsWith(“alf”)) 返回true

//是否以什么字符串结尾

if(s.endsWith(“exe”)) 可以使用该方法判断文件名的后缀名

//替换

a.replace(“a”,”111”)//把字符串的所有的a替换为111

但是这样只能替换某一个

如果想要替换所有的数字，或者所有的字母，变为某个文字

则使用a.replaceAll

//替换所有的数字变为%

a.replaceAll(“\d”,”%”)所有的数字变为%

//截取字符串

a.subString(0,5);开始位置，介绍位置

//拆分

String ss = “abc,12,df,78”;

String[] values = ss.split(“,”)以逗号分割，如果是转义字符，需要加/

//查找

s.contains(“ab”) //返回一个字符串是否存在

int index = s.indexOf(“12”)//返回12所在的位置， index = 4;从前往后找，返回-1就代表找不到

12.值传递和引用传递

Java 编程语言只有值传递参数.

当一个对象实例作为一个参数被传递到方法中时,参数的值就是对该对象的引用.对象的内容可以在被调用的方法中改变,但对象的引用是永远不会改变的.

A a= newA（）；

a就在堆地址里面，a就是引用传值

13.static（静态）

1.static 修饰的会一直存在内存中，直到程序退出内存才会释放

2.static 一般修饰内部类

3.1静态变量或方法，属于类而不属于对象

3.2所以调用静态变量或方法时，应该使用类名直接调用，而不是使用new 的对象去调用

3.3静态变量在内存中只保存一份，由这个类共享，

4.当类初始化的时候static（变量或方法）就会存在，生命周期很长，比较会占用内存空间，程序退出了内存才会回收

5.静态（static）方法不能调用非静态数据

.class文件通过classLoader类加载器，加载到运行时数据区，（静态方法区，栈，堆）

static 不属于对象，属于类，不能引用this，super

14.对象数组

//动态数组，这个算法，比较好，不浪费内存

int count = 0;数组的长度

public void add(String a){



String [] s= new String[3];

if(count>=s.length()){

//int newLength = s.length()*2;扩充2倍

int newLength = s.length()/3*2+1;//增加一半容量

s = Arrays.copyOf(s,newLength)//扩展数组的容量并且把以前数组的数据放进来



}

s[count] = a;

count++;

}



删除数组中的某一个

public void delete(int id){

for(int i = 0;i<count;i++){

if(s[i]==id) {

for(int j = i;j<count;j++) {

s[j] = s[j+1]

}

s[count -1] = null;

count ++

}

}



}

15.加强for循环可变参数与代码块

1.好处：不用担心下标越界

//String ...使用时当做数组使用,可以传多个出来，相当于new了一个数组

2.public void test(String ... params){



for(String s : params){



}

}

错误的写法：

2.public void test(int.. x,String ... params){



for(String s : params){



}

}



这样是错误的，可变参数只能有一个

3.public void test(String ... params,int z){



for(String s : params){



}

}



这样也是错误的，可变参数只能放在最后一个参数







代码块：

public class test(){

{

System.out.println("构造快")

}

public class test(){

}

static {

System.out.println("静态块，编写只需要初始化一次的操作")    

}



public test(){

System.out.println("构造方法")

}

执行顺序：静态块–>构造快–>构造方法

在有main方法的情况下：静态块–>main–>构造快–>构造方法

}

作用：

静态代码块优先于类存在，是给类进行初始化。

构造代码块，构造代码块给所有的对象进行初始化。

构造函数是给对应的对象进行实例初始化。

即：静态代码块是给类进行初始化的，构造代码块是给所有的对象进行初始化的

16.单例设计模式

单例：保证一个类只有一个实例，并提供一个访问它的全局访问点

1.饿汉式

class Single{

private static Single mInstance= new Single();//因为太饿了，着急，所以定义的时候就new出来了

1.构造方法私有化

private Single(){}

2.提供一个本类的对象

public static Single getInstance(){

return mInstance;

}

//自己定义的方法

public void method(){}

使用：

Single s = Single.getInstance();

s.method();

}

2.懒汉式

class Single2{

private static Single2 mInstance= null;//不着急，什么时候用，什么时候再new

1.构造方法私有化

private Single(){}

2.提供一个本类的对象

public static Single getInstance(){

if(mInstance == null){

mInstance = new Single();

}

return mInstance ;

}

//自己定义的方法

public void method(){}

使用：

Single s = Single.getInstance();

s.method();

什么情况下使用用单例模式：

1.通常在工具类的设计中使用，因为工具类通常是没有属性的，全是方法，那么调用一个方法就要new一次，浪费内存，

2.当一类中没有属性

3.该类作为工具类使用非常频繁

就比如Volley中的queue方法只需要实例化一次。

17.继承，重写

1.面向对象三大特征之一

2.父类也叫超类，子类也叫派生类

3.子类继承父类的属性和方法

4.继承的好处：代码重用

注意：

1.如果属性需要被子类继承，那么可以用protected关键字声明

2.构造方法不能被继承

子类实例化过程：

先让父类实例化（先执行父类的构造方法），之后自己再实例化（再执行自己的构造方法）

子类实例化时，会先调用父类的构造方法；如果父类没有默认的构造方法（即父类有了一个或者多个带参的构造方法，因为一个类在有一个或者多个有参构造方法的时候，想要用无参构造方法，必须手写一个空的无参构造方法,手写的无参构造方法也叫默认的构造方法；如果不写，默认的构造方法就被有参的构造方法覆盖了，此时父类中就只有一个有参的构造方法了），那么子类必须显示的（super(name)调用父类的带一个参数的构造方法，也可以super(name，name2)）调用父类的构造方法

注意：在子类构造方法中，super（）必须要在子类否则方法的第一行调用，因为这样才能先执行父类的方法

方法重写(覆盖)：

1.方法的返回值，方法名，参数列表必须完全一致

2.子类抛出的异常不能大于父类的异常

3.子类方法的访问级别不能低于父类方法的访问级别（public>protect>private）

4.调用父类的属性的时候super有时候可以省略.

调用父类构造方法super(),

调用父类属性super.name （扩展属性就是：变量，常量等）

调用父类方法super.test()

18.final关键字和抽象类，接口语法

1.final关键字（最终的意思）

1.final申明的类不能被继承（最终类）

2.final申明的方法不能被重写（最终方法）

3.final 申明的属性为常量

4.两种赋值方式：

直接赋值：final int num = 1;必须要有值，final int num;(这是错误的)

构造方法赋值：

但是可以这样赋值：

final int num;

public finalClass{

num = 1;

}

2.抽象类abstract

2.相同特征和行为的对象抽象为一个类（共同的特征）比如：动物，人类，

很多相同特征和行为的类可以抽象为一个抽象类

abstract void eat();抽象方法

应用：

package com.test.testjva;

public abstract class Person {

    public abstract void eat();

}



package com.test.testjva;

public class Man extends Person{

    @Override

    public void eat() {

        System.out.println("我是男人，吃饭大口吃");

    }

}

package com.test.testjva;

public class Women extends Person{

    @Override

    public void eat() {

        System.out.println("我是女人，吃饭慢慢吃");



    }

}

作用：就是被子类继承用的（因为它的含义是一个类别，很多对象的统称）

注意：

1有抽象方法的类一定是抽象类

2抽象类不一定有抽象方法

3具体类继承抽象类必须要实现抽象方法

4抽象类不能被实例化（不能new）

5抽象类不能申明为final

3.接口（中间人）

1.接口是一组行为的规范，定义（比如法律，合同，就是必须无条件执行才有意义）

2.程序多变化

3.思想精髓之一

interface test{

public default void pri()//jdk1.8刚出的方法

String info = “打” 接口里的属性默认是（即省略了）public static final (通常定义常量就是直接通过test.info调用的，所以static和final 一般结合使用)

void a();接口中的方法默认为public

}

1.接口可以继承多个接口

2.一个类可以实现多个接口

3.抽象类实现接口可以不实现方法（因为抽象类不是一个具体类，public abstract void eat();这种写法就代表不是具体类）

4.接口中的所有方法属性访问权限都是public

5.接口中定义的属性都是常量

当接口作为参数时，传递的值是实现了这个接口的很多实现类中的一个，（即传接口，就是传实现类就对了，传哪个实现类，调用的就是哪个实现类里面的方法）

接口可以new，new的过程中，必须要实现接口里面的方法，相当于创建了一个实现了该接口的内部类

19.多态

1.方法的重载与重写（名字一样，不同的情况执行不一样）是多态的一种概念

2.对象的多态性

理解：一个人，在公司是员工

在小孩是爸爸

在爷爷是孙子

在夫妻是丈夫

不同的角色行为不一样

比如你可以跟妈妈撒娇，不能跟儿子撒娇

关于多态的例子不胜枚举。比方说按下 F1 键这个动作，如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；如果当前在 Word 下弹出的就是 Word 帮助；在 Windows 下弹出的就是 Windows 帮助和支持。同一个事件发生在不同的对象上会产生不同的结果。

多态：

1.可以用大的去表示小的

比如

//用父类的引用（Cat cat ）指向子类对象（new HomeCat();）

Cat cat = new HomeCat(); 小的（家猫）可以自动转换为大的（猫类）

Cat catye = new yeCat(); 小的（野猫）可以自动转换为大的（猫类）

HomeCat extends Cat

yeCat extends Cat

即向上转型（基本数据类型中的自动转换：小的转为大的）

向下转型：如果用HomeCat cat = (HomeCat)new Cat();属于强转，可能会丢失精度

但是强转只能是大转小，不能HomeCat catye = new yeCat(); （错误的写法）会报错：classCastException 类转换错误

2.传不同的参数，有不同的效果，（这就是多型态）

小结：

1.方法的重载与重写就是方法多态性的表现

2.多个子类就是父类中的多种形态

3.父类引用可以指向子类对象，自动转换

4.子类对象指向父类引用需要强制转换（注意：类型不对会报异常）

Cat homeCat = new HomeCat();

HomeCat homecat= (Cat)new Cat();//正确的写法

YeCat yecat = (Cat)new Cat();//错误的写法会报错classCastException

解决保存方法：

if(cat instanceof YeCat) {//检查对象是否为某个类型（大类instanceof 具体对象），

判断这个猫是野猫么，是野猫就转换

YeCat yecat = (Cat)new Cat();

}

5.在实际开发中尽量使用父类引用

针对抽象的类型去写代码，其他继承这个抽象类的对象就都有这个方法了

原则：对修改关闭，对扩展开放

instance作用：检查对象的类型

父类设计原则：

1.父类一般都设计为抽象类或者是接口

2.其中优先考虑接口，次之考虑抽象类

一个具体的类尽量不要去继承另一个具体的类，这样的好处就是无需检查对象是否是父类的对象 （父类 instance 子类）

如果你的子类中有除了父类的方法的其他扩展方法，当你使用的时候直接new YeCat();然后去调用

就不要用

Cat cat = new YeCat();

if(cat instance YeCat){

调用

}

抽象类和接口的区别：

抽象类是很多对象的类别，而接口是比抽象类更加抽象

接口相当于是定义行为（吃，打）因为接口里面都是方法，没有属性（变量。。）

Docker步步实践

目录文档：

①Docker简介

②基本概念

③安装Docker

④使用镜像：

⑤操作容器：

⑥访问仓库：

⑦数据管理：

⑧使用网络：

⑨高级网络配置：

⑩安全：

⑪底层实现：

⑫其他项目：

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

目录文档：

[外链图片转存中…(img-cxjWAKeW-1715624177011)]

[外链图片转存中…(img-kB7ZGoT9-1715624177011)]

①Docker简介

②基本概念

③安装Docker

[外链图片转存中…(img-GBOH3pcj-1715624177012)]

④使用镜像：

[外链图片转存中…(img-anWdHTC0-1715624177012)]

⑤操作容器：

[外链图片转存中…(img-TCLvuaQx-1715624177013)]

⑥访问仓库：

[外链图片转存中…(img-YOc0keUD-1715624177013)]

⑦数据管理：

[外链图片转存中…(img-oN62Jygc-1715624177014)]

⑧使用网络：

[外链图片转存中…(img-DCqWdpuL-1715624177014)]

⑨高级网络配置：

[外链图片转存中…(img-a8gYgQbh-1715624177014)]

⑩安全：

[外链图片转存中…(img-VL140QjX-1715624177015)]

⑪底层实现：

[外链图片转存中…(img-RAOa1llo-1715624177015)]

⑫其他项目：

[外链图片转存中…(img-XshgPO5k-1715624177015)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取