Android学习-JAVA基础 (一)，毕业工作5年被裁

| 双精度浮点型 | double | 8 | 0.0d |

| 长整形 | long | 8 | 0 |

2. 基本数据类型转换

1.自动转换,容量小的类型自动转成容量大的数据类型

int a = 10;

float x = a;

byte b = 20;

//byte c= b+1;由于在运算时1为整数，与B运算完后还是整数，不能直接赋值给byte

int c = b+1;

2.强制类型转换容量大–》容量小,容量（字节）（要考虑是否会照成精度降低）

byte d = (byte)a;

char c1= ‘a’;

char c2 = ‘b’

int x1 = c1;

int x2 = c2;

x1= 97 x2= 98 （asc2码）

转义字符

3.运算符与优先级

int a = 10;

int b = a++;//先赋值后加

结果：

b=10;

a= 11;

int a = 1;

int b = ++a;//先加后赋值

结果：

b = 2;

a = 2;

int y1 = 10；

int y1 = y1 +3; //从右往左算或者y1+=3;

3.^(异或)相同为false，不同为true

4.continue 结束当前单次循环

break 结束循环

4.数组与算法

1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其

操作方式类似于数据结构中的栈。

2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回

收 new 的对象在堆里面，所以不要一直new，视情况使用单例实现，只new一次，对于那些只需要一个实例的对象

5.冒泡排序,选择排序

package com.group.buy;

public class Test {

    //冒泡排序,相邻的从左往右比较，右边比左边一个大，则交换

     int number[] = {1,5,6,33,4};

     /*

      * 1,5,6,4,33,

      * 1,5,4,6,

      * 1,4,5

      * 1,4

      * 1

*/

     int temp;

    public  void BubbleSort(){

        for (int i = 0; i < number.length -1; i++) {//循环多少轮

            for (int j = 0; j < number.length -1 -i; j++) {//每轮循环多少次

                if(number[j] > number[j+1]) {//如果第一个数>第二个数，那么交换，因为从左到右，从小到大比较

                    temp = number[j];

                    number[j] = number[j+1];

                    number[j+1] = temp;

                }

            }



        }

        for (int i = 0; i < number.length; i++) {

            System.out.println("=="+number[i]);

        }

        SelectionSort();

    }



    //选择排序，假定第一个最小，每一个都与第一个比较，如果有比第一个小的，则交换位置，比完了，下一轮则用第二个数与待比较元素比较，有比它小的，则交换位置

    int numberChange[] = {2,5,18,3,23,89,8};

    /* 先比当前第一个: 2,5,18,3,23,89,8

     * 再比当前第二个: 2,3,18,5,23,89,8

     * 再比当前第三个: 2,3,5,18,23,89,8

     * 再比当前第4个: 2,3,5,8,23,89,18

     * 再比当前第5个: 2,3,5,8,18,89,23

     * 再比当前第6个: 2,3,5,8,18,23,89

     * 

*/



    public void SelectionSort(){

        int minIndex = 0;//最小数的索引

        int temp = 0;//临时交换用

        for (int i = 0; i < numberChange.length - 1; i++) {//6轮，要比较的轮数

            minIndex = i;

            for(int j = i + 1;j<numberChange.length;j++){



                if(numberChange[j]<numberChange[minIndex]) {//如果当前的数字比第一个还小，把当前index作为最小值的index

                    minIndex = j;

                }

            }



            if(minIndex != i) {//如果当前的index和第一个数字的index不一致，那么把筛选出来的那个最小的值与第一个交换位置

                temp = numberChange[minIndex];

                numberChange[minIndex] = numberChange[i];

                numberChange[i] = temp;

            }



        }



        for (int i = 0; i < numberChange.length; i++) {

            int j = numberChange[i];

            System.out.println("=="+j);



        }

    }

}

6.面向对象基本概念

一丶什么是面向对象

1.面向对象是一种编程思想

2.是一中思考问题的思维方式

二丶建立面向对象的思维方式

1.先整体，在局部

2.先抽象，再具体

3.能做什么，在做什么

三丶如何学习

1.掌握一门面向对象语言语法

2.熟悉面向对象的设计原则

3.熟悉面向对象的设计模式

7.对象内存分析

1.new 代表申请一个内存空间。

2.所有的-方法里面的变量（局部变量）存在栈中。也叫基本数据类型

String a = 1; Sting a = new a（）；

a在堆内存中

3.成员变量也叫全局变量。

1.

Store s = new Store();//new一个后面保存的就是地址

        s.setStoreName("111");

        Store s2 = s;//s,s2同时指向了new Store()一个对象，因为只new了一次

        s2.setStoreName("222");

        s.getStoreName() = 222



2.

        Store s = new Store();

        s.setStoreName("111");

        Store s2 = new Store();

        s2 = s;//这个时候s2之前new store()分配的堆内存空间就被gc回收了，s2和s1同时指向了s1的堆内存（也就是说共用同一个堆内存，所以你改变s2的值，也就相当于是改变了s的值）

        s2.setStoreName("222");

        ToastUtils.show(this, s.getStoreName());

当堆里面的对象没有被引用的时候，就视为是垃圾

这个时候hourse1的name=黑黑，因为它们指向的是同一块内存

8.封装性

错误：

class Dog{

private int totalSize;

    private Store[] storeList;  

}

Dog d= new Dog();

d. totalSize(这种写法是错误的，因为你不能直接修改private私有的变量)

正确：

private int totalSize;

    private Store[] storeList;

    public int getTotalSize() {

        return totalSize;

    }

    public void setTotalSize(int totalSize) {

        this.totalSize = totalSize;

    }

    public Store[] getStoreList() {

        return storeList;

    }

    public void setStoreList(Store[] storeList) {

        this.storeList = storeList;

    } 

提供get,set方法，就可以通过set方法修改他的值了

Dog d= new Dog();

d.setTotalSize(22);

理解：你想得到别人的书，不能抢，要去借，因为别人已经封装好了（private），

抢就代表直接强制性的赋值

借不是强制性的，比如你调用了d.setTotalSize(22);

但是public void setTotalSize(int totalSize) {

//this.totalSize = totalSize;

人家注释了，也就是说不想借给你，这样的话就是有选择性，我可以不接受，

}

封装的意思：private（私有的）+get+set（可拒绝，可同意）

比如一个庞大的系统有很多个小系统组成，那么每个小的系统就是每一个封装

9.构造方法和方法的重载

1.每个类默认情况下都有一个无参的构造方法

2.作用：初始化属性

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–>构造快–>构造方法

}

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip204888 （备注Android）

最后

在这里小编整理了一份Android大厂常见面试题，和一些Android架构视频解析，都已整理成文档，全部都已打包好了，希望能够对大家有所帮助，在面试中能顺利通过。

喜欢本文的话，不妨顺手给我点个小赞、评论区留言或者转发支持一下呗

集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。**
[外链图片转存中…(img-YrELCk6e-1712072277460)]
[外链图片转存中…(img-TEzYLrc2-1712072277461)]
[外链图片转存中…(img-7BVGKCBF-1712072277461)]
[外链图片转存中…(img-uOxcmV4Y-1712072277463)]
[外链图片转存中…(img-XSezpeai-1712072277463)]
[外链图片转存中…(img-viBKxpKh-1712072277463)]

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加V获取：vip204888 （备注Android）
[外链图片转存中…(img-jbKgbkUQ-1712072277464)]

最后

在这里小编整理了一份Android大厂常见面试题，和一些Android架构视频解析，都已整理成文档，全部都已打包好了，希望能够对大家有所帮助，在面试中能顺利通过。

[外链图片转存中…(img-4oUKecFk-1712072277464)]

[外链图片转存中…(img-wYVYRYWz-1712072277465)]

喜欢本文的话，不妨顺手给我点个小赞、评论区留言或者转发支持一下呗

本文已被CODING开源项目：《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》收录