【无标题】

总结

1数据类型

1.1数据分类

基本数据类型：

数值型（整数型（byte，short,int long） 浮点型（Float double））

字符型（char）

布尔型（boolean

引用数据类型：

类 数组 接口

ASCLL码：

a=97

A=65

0=48

1.2数据类型的使用

数据类型 名字=值;

整数型默认为int型

小数默认为double型

字符可以转换为对应的ASCLL码

char c1='a';

int i1=c1;

System.out.println(i1);    97

转义符（\）:把有意义的字符转换为无意义的字符

1.3类型转换

八种基本类型，除了布尔型。其他的均可以进行转换

自动转换：低精度到高精度自动转换

byte short char int 运算结果过默认为int

强制类型转换：高精度到低精度为强制转换

byte b=5;

int i=b;

b=(byte)i

byte->short->int->long->float->double

(char)

2.变量

2.1常量

常量在程序的整个生命周期中,值不可更改

字面量/直接量

字面量也是有数据类型的

整数默认是整型 int

小数 默认是double

final修饰的值不能更改

2.2变量

可以更改的量,方便进行操作,并且可以复用

2.3全局变量

全局 : 允许在类外创建变量,和类同级别,所有类都可以直接访问这个变量,不需要二次引用

所谓二次引用,就是指  没有使用 . 操作符  xxx.xxx

而在java中类之外是不允许写变量的,但是可以把一个变量的访问权限设置为public,然后通过类名进行引用调用即可

全局的缺点 就是命名冲突问题

2.4变量声明

数据类型  变量名=值；

2.5变量作用域

一个大括号为一个作用域，一个变量的作用域不会超过这个大括号

2.6变量分类

局部变量  成员变量（成员和静态成员，静态成员又称为静态变量）

局部变量：在方法中声明的变量称为局部变量，该变量只能在该方法中使用

                  直接通过名字调用该变量即可，且局部变量没有默认值，必须赋值

静态变量：在类体中使用static声明的变量，和方法是平级

                 通过类名.静态变量名才能调用，在当前类中调用时，可以省略类名

                 整数默认为0  小数默认为0.0   布尔型默认为false  字符型默认为\u0000  引用类型  null

成员变量：在类体中没使用static声明的变量，和方法是平级

                  成员变量需要通过  对象引用.成员变量才能调用

                  默认值和静态变量一样

3.运算符

3.1算数运算符

不要判断小数相等

++i:先加1，在赋值

i++:先赋值，再加1

优先级：单目>双目>三目

3.2位运算符

&：两边都是真，结果才是真，如果两边是数值，则为与运算

|：两边一个为真，就为真

！：取反

^：两边都不一样，结果为true

~：按位取反   0000 0000   取反位，然后求反码，补码，结果（简便记忆A=-(A+1)）

>>:右移运算符，二进制右移动两次，正数，左边补0（符号位后），负数补1

<<:左移运算符，二进制左移动两次   补0

>>>:右移运算符   不考虑符号位，符号位前补0，并且只补0

&&：两边都为真才为真，判断时，前边为false,后边不执行

||:一边为真就为真，判断时，前边为true，后边不执行

3.3赋值运算符

+=：左右相加，赋值给左边

左结合：同等优先级，先算左边

右结合：同等优先级，先算右边

3.4字符串拼接

两边位数字，+为求和

有字符串，+为拼接

3.5三目运算符

语法：布尔型表达式？真：假；

布尔型为true,执行真，false执行假

4流程控制

控制程序的不同执行分支

4.1顺序结构

严格从上到下从左到右

4.2分支结构

通过指定的判断条件，选择执行不同的分支

4.2.1  if…else…

单分支：有不执行情况

             if(布尔表达式){

            为真时执行的代码    

         }

双分支：一定有一个分支执行

             if(布尔表达式){

            为真时执行的代码

           }else{

               为假时执行的代码

          }

多分支：if(布尔型表达式){}  else if(布尔表达式){} else if(布尔表达式){}……

             多分支最后以else结尾，肯定有一个分支执行

             多分支以else  if  有不执行情况

每个分支下如果只有一行代码，{}可以省略

4.2.2  Switch

语法：switch(值){case值1：执行语句；break;

                            case值2：执行语句；break;

                           case值3：执行语句；break;

                             default:执行语句；break;

}

4.3循环结构

4.3.1For

4.3.1.1单循环

for循环语法结构：

for(初始化操作；终止条件；步长){

循环体

}

4.3.2  While

while:真假循环，条件为真，就执行，为假就终止

语法：

while(布尔型){

循环体

} 

4.3.3  Do…while…

可以保证循环至少执行一次

语法结构：

do{

循环体

}while(布尔型)

4.3.4 break和 continue

break:

可以在switch中，用来结束case分支

可以在循环中，结束当前循环

在嵌套循环中，可以结束内层循环，如果给外层循环加上名字（ab:for），break abfor可以终止外层循环

continue:跳过当前次循环，继续下次

5.方法

5.1概述

方法就是很多条语句的集合，把这些代码放到方法中，可以多次使用这个方法

方法目的：代码复用，使程序更加简单清晰，提高开发效率

5.2 方法声明

修饰符列表  返回值类型 方法名（参数列表）{方法体}

修饰符列表：可以有，可以没有，可以多个

返回值类型：11种数据类型中的任意一种，如果不需要返回值，则写void

方法名：方法的名字，望文知义，驼峰命名法

参数列表：要做一件事，需要的必备条件，可以作为入参

                  有多个用逗号隔开，    int a, int b , intc……

                  形参：在方法声明的时候，定义的参数列表

                  实参：方法调用时，实际传入的的数据

方法体：需要执行的代码

                 return 终止方法并返回

如果有返回值类型的方法中，必须有return语句

public static int m1(){

return 1;  只要是int值就行

}

如果没有可以不写，写了只能终止运行，不能返回数据

5.3  方法分类

静态方法：使用static修饰的方法，是静态方法

成员方法：没有static修饰的方法，是成员方法

构造方法：是每个类都有，并且用于创建该类对象

调用：

静态方法：类名.静态方法名（参数），同类中，类名可以省略

成员方法：对象引用.成员方法名（参数）

方法不调用不执行，调用才执行，并把结果返回到调用处

5.4入参和出参

入参：做这件事需要的未知条件

出参：做完这件事需要进行的反馈

5.5方法重载

方法唯一性：方法名和参数

方法重载（overload）：方法名相同，参数列表不同

列表不同分为：个数不同和类型不同

6.内存分析

6.1内存划分

 

Java Runtime Data Area : java运行时区域,一般叫JVM内存  

   程序计数器 :

                     一块较小的内存区域.作用可以看做是当前程序执行的位置指示器

   静态区/方法区 :

                     保存程序文件(class文件) 以及静态数据,方法被调用之前,也保存在静态区,内部还有运行时常量池

   

 VM栈 : 又叫栈内存

                    栈内存是以栈数据结构为模型开辟的一段空间, 特性是先进后出

                     栈 : 是一种数据结构,先进后出,像弹夹

   

    栈的构成因素

             栈空间 : 栈内存就是栈空间

            栈帧         : 栈空间中的每一个栈元素 就叫栈帧(比如 弹夹中的每一个子弹 就叫栈帧)

            栈底元素 : 第一个放进去的栈帧

             栈顶元素  : 最后一个放进去的栈帧

  栈操作

            压栈 : 就是指把元素放入栈空间的过程

             弹栈 : 就是把元素弹出去的过程

 

  栈内存,是用来执行方法的,所有方法的执行,必须在栈内存进行

 本地方法栈 :

             用来执行一些本地方法,比如hashCode 等 , 模型和操作都和VM栈一致 , 不用管,

   

   堆内存 :

                     用来保存对象

7.递归

7.1概述和基本使用

递归：方法中调用当前方法（自己调用自己）

递归思想：递归和迭代是等价的，就是循环

                 基本思想就是以此类推

常见问题：所有树状结构

                  文件夹复制

                  斐波那切数列

  斐波那切数列

publicc static void main(String[] args){

int result=factorial(10);

System.out.println(result);

}

public static int factorial(int n){

if(n==1||n==2){

return

}else{

return factorial(n-1)+factorial(n-2);

}

}

8.数组

8.1数据结构

数据结构是计算机存储、组织数据的方式

数据操作：增删改查

8.2数组特性：

内存中连续存储,并且下标从0开始

 数组长度一旦确定 长度不能更改,也就意味着数组是不能添加和删除的

除非新建一个数组,把原数据复制到新数组中,在复制的过程当中可以进行添加和删除操作

所以 数组的查询和更改 效率是很高的,但是 添加和删除效率较低

数组都有一个内置属性 length  保存了数组的长度

 在java中 有一个java.util.Arrays 类 提供了一些数组操作

8.3数组声明

静态声明：已知每个元素

数据类型[]  变量名={值1，值2，值3……};

数据类型[]  变量名=new 数据类型[]{值1，值2，值3……};  数组二次赋值需要这样写

动态声明：不知道数组中的每个元素的时候

数据类型[]   变量名=new  数据类型[长度];

8.4数组使用

8.4.1更改数据

数组[下标]=值；

8.4.2遍历

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

System.out.println(arr[i]);

}

8.4.3数组传递

m2(new int[]{1,2,3})   数组字面量传递方式

8.4.4mian方法传参

 

 8.5传值和传址

传值：指的是传递基本类型的数据

传址(传引用)：指的是传递引用数据类型的值

基本类型传递之后，相互没有影响，因为指向不同的空间

引用类型传递之后，相互有影响，因为指向同一个堆内存对象空间

9 二维数组

9.1声明方式

静态声明： int[][] arr={{1,2,3},{2,5},{5}}

动态声明：int[][] arr=new int[3][4];表示该二维数组中，有3个一维数组，并且每个一维数组中都有4个数据

int[][] arr=new int[3][];表示该二维数组中，有3个一维数组，并且这三个一维数组都是null

每个一维数组不一样的需要单独初始化

arr[0]=new int[5]

arr[1]=new int[4]

arr[2]=new int[9]

9.2存储方式

int[][] arr={{1,2,3},{2,5},{5}}

9.3 使用方式

9.3.1获取方式

将二维转换为一维，在获取一维

9.3.2更改数据

数组[下标][下标]=值

9.3.3遍历

使用嵌套循环

10.排序

排序：就是指让保存的元素按照一定的规则进行排序存储

10.1冒泡排序

1.比较相邻的元素，如果第一个比第二个大，就交换他们两个

2.对每一对相邻元素做相同的工作，从开始第一对到结尾的最后一对

3.针对所以元素重复以上的步骤，除最后一个

4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要准备

 10.2选择排序

1.每次把最小的放到左边

     拿出第一个，假设是最小的，然后挨个和后面的比较，如果有比第一个小的，就交换下标

     比较完一轮后，得到最小元素下标，放到前面

2.重复上面步骤，直到当前元素后面没有元素时终止

 11.查找元素

11.1顺序查找

遍历，用所有数据挨个和目标数据进行比较

11.2二分查找

也叫折半查找

要求数据必须有序

1 确定开始和结束还有中间数据

2 用目标数据 和 中间数据进行比较

3 如果目标数据等于中间数据,返回中间数据的索引即可

4 如果目标数据大于中间数据的话,则在后半截继续查找,起始=中间+1,结束不变,再生成中间数据

5 如果目标数据小于中间数据的话,则取前半截,起始不变,结束=中间-1,再生成中间数据

6 重复执行以上步骤,如果起始 大于 结束 说明未找到,返回-1

 12. 面向对象

12.1概述

面向对象(Object Oriented)是软件开发方法，一种编程范式。面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。

面向对象是相对于面向过程来讲的，面向对象方法，把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式。

12.2面向对象和面向过程

面向过程：侧重分步骤

面向对象：侧重分模块

面向对象优势：可扩展性，可维护性，灵活性，使程序耦合度降低

缺点：性能比面向过程相对较差

12.3构造方法

构造方法：是每个类都有，并且用于创建该类对象

如果该类中没有编写构造方法，那么编译器会自动帮我们成一个无参构造

如果该类中编写了构造方法，不管写得是不是有参，默认的无参构造都不在自动生成

所以当我们在写有参构造的时候，可以手动编写一个无参构造

构造方法语法： 修饰符  方法名（必须和类名一致）（参数列表）{方法体}

12.4类和对象

对象：就是某一个具体的事物

类：描述了这一类事物的属性和特征，进行抽象出的模板

对象就是类的实现，保存了属性的值

在编译中通过需求或者现实事物的属性和特征来定义相关的类

通过不同的属性值来定义不同的对象

如果对象和对象之间，有相同的属性相同的值，就使用静态变量

如果对象和对象之间，有相同的属性不同的值（也可以相同），就使用成员

12.5实例化

1.加载对应类文件

2.new在堆内存创建空间

3.执行构造方法，对堆内存对象进行初始化

4.构造方法弹栈，并把堆内存返回给变量

Student student=new Student();    变量

new Student();      字面量

12.6对象调用静态属性

静态属性可以使用类名调用，也可以使用对象调用（在编译阶段，会把对象转换为类名调用，该变量是不是null没有关系）

12.7注意事项

12.7.1静态调用成员

静态方法中无法直接使用非静态属性，需要使用对象调用

静态变量：对象之间共有的属性和值

成员变量：对象之间共有的属性不同的值，值也可以相等

成员方法：方法中需要使用成员属性的时候，定义为成员方法

静态方法：方法中不需要使用成员属性的时候，定义为静态方法

12.7.2传值和传引用

13 This

13.1概述

this:是每个对象中，保存自身内存地址的一个引用类型变量

this就表示当前对象

13.2 能做什么

1.在成员方法或者构造方法中，区分同名的成员变量和局部变量
                    this.xxx
 2.在构造方法中，重载调用当前类中其他构造方法，但必须写在构造方法第一行
                    this(xxx)
3.return this  返回当前对象的内存地址，可以链式调用
 谁调用这个成员方法，this就是谁
 注意 this不能使用静态方法中

13.3成员和局部

静态变量可以和成员变量同名

局部优先级高

使用类名区分同名的静态变量和局部变量

使用this区分同名的成员变量和局部变量

注意：this不能出现在静态上下文

14.Static

14.1概述

修饰符，关键字，用来区分静态和成员

14.2静态语句块

等同于静态方法

自动执行，在程序加载阶段执行完成，并且只执行一次

static{};

14.3实例语句块

可以看做成员方法，没有static修饰的语句块就是成员语句块

{      }

15.封装

把所有组成部分组合到一起,还可以通过权限控制修饰符将数据隐藏起来,可以控制用户对类数据的修改程度

适当的封装可以让代码更容易理解,易于维护,更提高了代码的安全性

Package

       软件包机制，主要解决了命名冲突问题

Import

       用于把当前类中需要的其他类载入，必须在class之上，package语句之下

权限控制

 

15.继承

15.1概述

已有的类中，派生出新的类，新的类用于父类的属性和行为

15.2功能

代码复用，提高效率，还可以进行覆写，可以使用多态

语法   class 类名 extends 父类名 {类体 }

16.Super

 代表了父类的特征，用在成员方法和构造方法中区分父子类之间同名的方法和变量super.xxx

   还可以用在子类方法中，调用指定的父类构造方法super（xxx）,必须出现在子类构造方法第一行

注意：

如果在子类构造方法中,没有显示出现super() 也没有出现 this(xxx)  则 默认有一个super() 调用父类无参构造

并且 super(xxx) 必须出现在子类构造方法 第一行  所以 this(xxx) 和 super(xxx) 不能同时出现

17.覆写

覆写特指成员方法，当父类功能无法满足子类需求时，进行覆写

 写一个和父类一样的方法，但是功能不同

规则：

      1 方法名，返回值，参数列表 必须和父类一致

       2 不能比原方法拥有更低的访问权限

       3 不能比原方法拥有更宽泛的异常