Android学习-JAVA基础 (一)

Docker步步实践

目录文档:

①Docker简介

②基本概念

③安装Docker

④使用镜像:

⑤操作容器:

⑥访问仓库:

⑦数据管理:

⑧使用网络:

⑨高级网络配置:

⑩安全:

⑪底层实现:

⑫其他项目:

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

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

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

 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.成员变量也叫全局变量。



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

    s.setStoreName("111");

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

    s2.setStoreName("222");

    s.getStoreName() = 222
    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());



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

> ![这里写图片描述](https://img-blog.csdn.net/20160202102242387)  

> 这个时候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();

> 

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

> 1.  

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

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

> String b= a1;  

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

> 2.  

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

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

> String b1 = “c1”  

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

> 3.  

> 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的值在编译期不能被确定(方法调用在运行期才能返回结果),所以不相等  

> 4.  

> 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”  

> 2.  

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

> //是否与字符串开头  

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

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

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

> 3.  

> //替换  

> 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.

> 

> 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("我是女人,吃饭慢慢吃");



}

}




> 作用:就是被子类继承用的(因为它的含义是一个类别,很多对象的统称)  

> 注意:  


# 最后

整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路,本文的重点是你有没有收获与成长,其余的都不重要,希望读者们能谨记这一点。

![image](https://img-blog.csdnimg.cn/img_convert/ee6bf768b38037607ec23a13b867a7b1.webp?x-oss-process=image/format,png)

![image](https://img-blog.csdnimg.cn/img_convert/9b4086a2ee3b03d30f44adc0ee041c60.webp?x-oss-process=image/format,png)

其实面试这一块早在第一个说的25大面试专题就全都有的。以上提及的这些全部的面试+学习的各种笔记资料,我这差不多来回搞了三个多月,收集整理真的很不容易,其中还有很多自己的一些知识总结。正是因为很麻烦,所以对以上这些学习复习资料感兴趣,

> **本文已被[CODING开源项目:【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】](https://bbs.csdn.net/topics/618154847)收录**

**[需要这份系统化的资料的朋友,可以点击这里获取](https://bbs.csdn.net/topics/618154847)**

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

> 

> 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("我是女人,吃饭慢慢吃");



}

}




> 作用:就是被子类继承用的(因为它的含义是一个类别,很多对象的统称)  

> 注意:  


# 最后

整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路,本文的重点是你有没有收获与成长,其余的都不重要,希望读者们能谨记这一点。

[外链图片转存中...(img-dvZq7AYr-1715808626068)]

[外链图片转存中...(img-XzABjg9t-1715808626068)]

其实面试这一块早在第一个说的25大面试专题就全都有的。以上提及的这些全部的面试+学习的各种笔记资料,我这差不多来回搞了三个多月,收集整理真的很不容易,其中还有很多自己的一些知识总结。正是因为很麻烦,所以对以上这些学习复习资料感兴趣,

> **本文已被[CODING开源项目:【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】](https://bbs.csdn.net/topics/618154847)收录**

**[需要这份系统化的资料的朋友,可以点击这里获取](https://bbs.csdn.net/topics/618154847)**

  • 8
    点赞
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值