Android学习-JAVA基础 (一)

1.八大数据类型

数据类型	关键字	占用字节	默认值
布尔型	Boolean	1	false
字节型	byte	1	0
短整型	short	2	0
字符型	char	2	\u0000’
短整型	short	2	0
整型	int	4	0
单精度浮点型	float	4	0.0f
双精度浮点型	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.运算符与优先级

1.
int a = 10;
int b = a++;//先赋值后加
结果：
b=10;
a= 11;
int a = 1;
int b = ++a;//先加后赋值
结果：
b = 2;
a = 2;

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();

//字符串直接赋值时，要看值咋编译器能不能确定，如果能确定，就会在常量池中创建，并指向该对象；如果不能，将在运行期的时候在堆内存中创建对象
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("我是女人，吃饭慢慢吃");

    }
}

作用：就是被子类继承用的（因为它的含义是一个类别，很多对象的统称）
注意：
1有抽象方法的类一定是抽象类
2抽象类不一定有抽象方法
3具体类继承抽象类必须要实现抽象方法
4抽象类不能被实例化（不能new）
5抽象类不能申明为final

3.接口（中间人）
1.接口是一组行为的规范，定义（比如法律，合同，就是必须无条件执行才有意义）
2.程序多变化
3.思想精髓之一
4.
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){
调用
}

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

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

20.模板方法设计模式

1.定义一个操作中的算法的骨架
2.可变部分延伸到子类中

示例：
package com.test.testjva;
public abstract class Person {

    public void play(){

        if(eat()) {
            System.out.println("吃饭");
        } else
            System.out.println("不吃");
    }
    public abstract boolean eat();
}

package com.test.testjva;
public class Man extends Person{
    @Override
    public boolean eat() {
        System.out.println("我是男人，吃饭大口吃");
        return true;
    }
}
package com.test.testjva;
public class Women extends Person{
    @Override
    public boolean eat() {
        System.out.println("我是女人，吃饭慢慢吃");
        return false;

    }
}

public static void main(String[] args) {
        Person p = new Man();
        p.play();
    } 

结果：
我是男人，吃饭大口吃
吃饭