相关知识了解：
------------------------------------------------------------------------------------------------------------------------
位(bit): 一个数字0和一个数字1代表一位
字节(Byte):每逢8位是一个字节，这是数据存储的最小单位
1Byte = 8 bit
1KB = 1024 Byte
...............
------------------------------------------------------------------------------------------------------------------------
1ZB = 1024EB
JVM:java虚拟机的简称
JRE：是java运行时的环境，里面已经包含了jvm和其他所需要的核心类库
JDK:是java程序开发工具包，包含jre和开发人员所需要的工具
JDK>JRE>JVM(核心)
------------------------------------------------------------------------------------------------------------------------
%--%：翻译中间的东西
------------------------------------------------------------------------------------------------------------------------
关键字：
有特殊含义的、被保留的，不能随意使用的字符。
特点：
1.完全小写的字母
------------------------------------------------------------------------------------------------------------------------
标识符：（命名规则）
1.不能以数字开头
2.不能是关键字
命名规范：
1.类名规范：首字母大写，后面每个单词首字母都大写(大驼峰模式)--HelloWorld
2.变量名规范：首字母小写，后面每个单词首字母大写(小驼峰模式)--helloWorld
3.方法名规范：同变量名
------------------------------------------------------------------------------------------------------------------------
常量：在程序运行期间，固定不变的量。
常量的分类：
1.字符串常量：双引号引起来的
2.整型常量：直接写上的数字，没有小数点
3.小数常量（浮点数常量）：直接写上的数字：1.2，5.3...
4.字符常量，用单引号引起来的单个字符，例如：'A','b','9','中'，（java当中允许有单引号中文）
--区别(字符串可以写很多，但字符只能写一个)
5.布尔常量：True/False
6.空常量：null(无任何数据)
------------------------------------------------------------------------------------------------------------------------
引用数据类型：例如字符串，数组，类，接口，lambda...
1、变量名指向存储对象的内存地址。
2、引用数据类型在声明后分配的是内存地址，不会分配内存。
3、引用数据类型是分配在堆上的。
4、引用数据类型使用equals方法去比较。（equals可以复写，比较相等，值是不是相同）
注：不论是基本数据类型还是引用数据类型，都会在栈中分配一块内存。
基本数据类型：(四类八种)：
四类：
1.整数型:Byte(字节型) , short(短整型) , long(长整型) , int(整型)(大约是-21个亿~21个亿)
2.浮点型:float(单精度浮点型) , double(双精度浮点数)--都是一个近似值--双精度更加精确--单精度更省空间
3.字符型:char--java当中的char类型是可以表示中文的
4.布尔型:boolean
注意事项：
1.字符串是引用类型，不是基本类型
2.浮点型是一个近似值，不是一个精确值
3.数据范围与字节数不一定相关float范围比long大，但是一个占4字节，一个是8字节
4.浮点数中默认的是double，如果要使用float，需要在后面加上--F
5.如果是整型，默认是int，如果要使用long，需要在后面加上--L
System.out.println(123);//默认的是int
System.out.println(123L);//这里代表的是long
------------------------------------------------------------------------------------------------------------------------
变量:程序运行期间，可以变的量
变量格式：
1.数据类型 变量名称
2.变量名称 = 数据值 //赋值：将右边的数据值，交给左边的变量
例如：
int i;
i = 100;
一步到位的格式：
数据类型 变量名称 = 数据值 //再创建一个变量的同时立刻放入指定的数据值
例如：int i = 100;//注意：左边的数据类型的范围不能超出
注意事项：
1.如果要创建多个变量，每个变量的名字不能重复
2.对于float和long类型的使用，一定不要忘了后缀F和L
3.如果使用Byte和short，右侧的数据值一定不能超过左侧的数据类型范围
4.没有进行赋值的变量，不能直接使用，一定要赋值之后才能使用
5.变量使用不能超过作用域的范围
【作用域】：从定义变量的那一行起，一直到直接所属的大括号结束为止
{
int num1 = 90;
System.out.println(num1); //正确的，两个大括号括起来的范围被称作作用域
}
// System.out.println(num1); //错误使用，不能超出作用域
int num1 = 10;
System.out.println(num1); //已经超过大括号范围了，原变量就不能再使用了，但是可以重新赋值
6.可以通过一个语句来创建多个变量--int a , b , c = 1,2,3
int a, b, c;
//先创建，给分别赋值
a = 10;
b = 100;
c = 1000;
System.out.println(a);
System.out.println(b);
System.out.println(c);
//一步到位的方法：
int q = 10, w = 100 ,e = 1000;
System.out.println(q);
System.out.println(w);
System.out.println(e);
------------------------------------------------------------------------------------------------------------------------
数据类型转换——自动转换：
System.out.println(1024); //整数，默认int类型
System.out.println(3.14);//浮点数，默认double类型
long num1 = 100L; //长整型
System.out.println(num1);
long num2 = 100;
System.out.println(num2); //当数据类型不一样是，将会发生类型转换
自动类型转换(隐式)：
1.特点：代码不需要特殊处理，将会自动转换
2.规则：数据范围从小到大
long num1 = 100 //一个等号代表赋值，将右侧的int类型，交给左侧的long类型进行储存
//int-->long,符合了数据范围从小到大原则
double num2 = 2.5F //同上
---long = 8字节 float = 4字节---
float num3 = 100L // float > long
强制类型转换：
1.特点：代码需要特殊格式的处理，不能自动完成
2.格式：小类型 小变量 = (小类型) 大数据
//long类型会被强制转换为int类型
int num1 = 100;
System.out.println(num1);
int num2 = (int)100L;
System.out.println(num2);
注意事项：
1.强制类型转换一般不建议使用，易发生精度损失、数据溢出
int num3 = (int)5000000000000L;
System.out.println(num3); //--输出结果为：658067456--由于long>int 所以 数据溢出
int num4 = (int)3.523974;
System.out.println(num4); //输出结果为：3 --由于int为整型，所以所有的小数位会被舍弃掉--导致精度损失
2.Byte/char/short类型都可以进行数学运算，例如：“+”
char zifu = 'A';
System.out.println(zifu+1); // 输出结果为：66 字符A被当作了65
计算机的底层会用一个(二级制)的数字来代表字符A
3.Byte/char/short类型再进行数学计算时候，首先提升为int类型，然后被计算
byte num5 = 90;
byte num6 = 10;
int result = num5 + num6; //在接收数据时，尤其是Byte/short/char 都需要用int来接收
System.out.println(result);
short num7 = 80;
short result2 = (short) (num5 + num7); // 用强制类型转换也可以实现，因为short的数据范围大于byte数据范围
System.out.println(result2);
4.boolean：不能用于数学运算
------------------------------------------------------------------------------------------------------------------------
ASCLL编码表：
1.可以查阅，没必要背
2.需要记住的三个：48-->0 65-->A 97--->a
char zufu = '1';
System.out.println(zufu + 0); //输出为49
------------------------------------------------------------------------------------------------------------------------
运算符：用来进行特定操作的符号
表达式：用运算符连起来的式子叫做表达式
1.算术运算符：=，-，*，/，
注意事项：
1.一旦运算当中有不同类型的数据，结果将会是数据范围大的一方
加号的多种：
四则运算当中的‘+‘ 有常见的三种用法
1.对于数值来说，即为加法
2.对于char类型来说，在计算之前，char会被提升为int，然后再计算
3.对于字符串来说，’+‘代表字符串的连接符号
4.任何数据类型和字符串相连的时候，结果都会变成字符串
自增自减的运算符：++/--
使用方式
1.单独使用：不和其他任何操作混合，自己独立作为一个步骤
2.混合使用：和其它操作混合，例如与赋值混合，或者与打印操作混合
使用区别：
1.在单独使用的时候，前++和候++是没有任何区别的
2.混合使用时：++num-->先加后用
num++-->先用后加
注意事项：
1.只有变量才能使用自增和自减运算符
------------------------------------------------------------------------------------------------------------------------
赋值运算符：
1.基本赋值运算符：就是一个“=”，将右侧的数据交给左侧的变量
2.复合赋值运算符：常见的：+= ，-= ， *= ， /= ， %=
注意事项：
1.只有变量才能使用赋值运算符
------------------------------------------------------------------------------------------------------------------------
比较运算符：< > == >= <= !=(不等于)
注意事项：
1.比较运算符的结果一定是一个布尔值，成立时true 不成立 false
------------------------------------------------------------------------------------------------------------------------
逻辑运算符：
1. 与(并且) && --> 全true 才true
2. 或(或者) || --> 只要有一个是true，就可以是true，全是false，才是false
3. 非(取反) ！ --> 本来是true，变成false。本来是false，变成true
4. ”与“ ”或“ 具有短路效果，如果左边已经可以判断最终结果，那么右边的代码将不再执行。节省了一定的性能
注意事项：
1.逻辑运算符只能用于布尔值
2.”与“ ”或“ 左右两边都需要布尔值 ，但是”取反“只需要唯一个布尔值
3.对于 1 < x < 3的形式 应这样写：x> 1 && x <3
------------------------------------------------------------------------------------------------------------------------
三元运算符：
格式： 数据类型 变量名称 = 条件判断？ 表达式A ： 表达式B
1. 如果条件判断为true，那么将表达式A的值赋值给左侧的变量
2. 如果条件判断为false，那么将表达式B的值赋值给左侧的变量
二者选其一
注意事项：
1.表达式A和B都需要符合左边的数据类型
------------------------------------------------------------------------------------------------------------------------
方法入门_概念引入：
1.定义方法的格式：
public static void 方法名称{
方法体
}
方法的命名规则和变量是一样的，小驼峰
方法体：大括号当中的任意语句
注意事项：
1.方法定义的先后顺序无所谓
2.方法定义不能有嵌套包含关系
3.方法定义好了不会被执行，如果想要执行，一定要进行方法的【调用】
方法的调用：
格式: 方法名称();
------------------------------------------------------------------------------------------------------------------------
编译器的两点优化：
1.对于byte/short/char三种类型来说，如果右侧的数值没有超过范围，那么编译器将会自动隐含的为其不上(byte)(short)(char)
如果右侧超过了左侧的范围，那么编译器则会直接报错
2.short a = 5
short b = 4
short result = a + b //错误写法，左侧需要时int类型
short result = 5+4 //正确=13，
注意：在给变量进行赋值时，如果右侧的表达式全是常量，没有任何变量，那么编译器将会之间将常量进行计算，不会在意左侧的类型
------------------------------------------------------------------------------------------------------------------------
流程概述：顺序结构 判断语句 循环语句
1.顺序结构
2.选择结构——单if语句
3.判断语句 if-else
4.复合扩展的if-else
------------------------------------------------------------------------------------------------------------------------
switch语句：
switch(){
case 常量值1：
语句体1；
break；
default：
语句体n+1;
break;
注意事项：switch小括号里面的数据只能是如下：
1.基本数据类型：byte/short/char/long
2.引用数据类型：String,enum枚举
3.switch 语句很灵活，不注意前后顺序，break也可以省略
4.如果没有break，当选择了某一个case，就会一直向下执行，这便是case的穿透力
------------------------------------------------------------------------------------------------------------------------
for循环语句：
1.基本结构：
1.初始化语句：在循环最初执行，而且只做一次
2.条件判断语句：如果成立，循环继续，不成立则结束
3.循环体：重复要做的事情
4.步进语句：每次循环都要执行一次：例如count+=1，i++。。。。。
while循环：
1.标准格式
2.扩展格式
do_while循环：第一次的执行是无条件的执行
------------------------------------------------------------------------------------------------------------------------
三种循环的区别：
1.如果条件判断从来没有满足过，那么for循环和while循环则会执行0次，而do-while循环则会执行1次
2.for循环的变量阿紫小括号内定义，儿do-while和while循环初始化语句就在外面
------------------------------------------------------------------------------------------------------------------------
break关键字的用法：
用来打断循环
continue:
一旦执行，立刻跳过当前次循环的剩余内容，马上开始下一次循环
死循环：
永远不停止的循环
------------------------------------------------------------------------------------------------------------------------
嵌套循环：
1.无论内循环循环多少次，外循环循环一次，就可
------------------------------------------------------------------------------------------------------------------------
常用快捷键：
1.alt+/ : 补充提示语句
2.alt + enter : 导包
3.ctrl+y :删除当前行
4.ctrl+alt+l:格式化代码，自动对齐
5.alt+insert : 自动生成代码，方法等。。
6.alt+shift:移动代码上下行
------------------------------------------------------------------------------------------------------------------------
方法的定义格式：
1.方法即是若干语句的功能结合--两个关键-->参数和返回值
参数(原料)：进入方法的数据
返回值(产出物):就是从方法中出来的数据
2.定义方法的完整格式：修饰符 返回值类型 方法名称(参数类型，参数名称，。。)
方法体
return 返回值
三要素：
1.返回值类型：返回值注意：第一return停止当前方法
2.方法名称：小驼峰
3.参数类型：
方法的三种调用格式：
1.单独调用：方法名称（参数）
2.打印调用：System.out.println(方法名称(参数));
3.赋值调用：
------------------------------------------------------------------------------------------------------------------------
方法重载(Overload):多个方法的名称一样，参数类型不一样。
好处：只需要记住唯一一个方法名称，就可以实现类似的多个功能
------------------------------------------------------------------------------------------------------------------------
引申：
1.public:公开属性
2.static：静态变量
3.void:空引用
------------------------------------------------------------------------------------------------------------------------
数组：是一种容器，用来存放数据类型
数组的特点：
1.数组是一种引用数据类型
2.多个数据，类型必须统一
3。数组的长度不可变(在运行期间)
数组的初始化：在内存当中创建一个数组，并且向其中赋予一些默认值
两种常见的初始化方式
1.静态初始化(指定长度)
2.动态初始化(指定内容)
初始化的格式：数组类型[] 数组名称 = new 数据类型[数组内容/长度]
new:代表的是创建数组的动作
直接打印数组名称，得到的是数组对应的，内存地址哈希值
所有的引用类型变量都可以赋值为一个null，代表其中是空值
空指针异常-->NullPointer
获取数组的长度：length
------------------------------------------------------------------------------------------------------------------------
java内存划分为5个部分：
1.栈(Stack):存放的都是方法中的局部变量，方法的运行一定要在栈当中
局部变量：方法的参数或者是内部的变量
作用域：一旦超出作用域，立刻从栈内存中消失
2.堆(Heap):凡是new出来的东西都在堆当中
3.方法区：存储.class相关信息，包含方法的信息
4.本地方法栈
5.本地寄存器
------------------------------------------------------------------------------------------------------------------------
数组元素反转：
1.对称位置的元素互换
2.交换的关键在于利用第三个参数
3.表示对称位置需要两个索引
停止交换：
1.min==max
2.min>max
------------------------------------------------------------------------------------------------------------------------
数组作为方法进行参数传递
public static void main(String[] args) {
int[] array = {1,2,3,4,5};
array(array);
}
public static void array(int[] array){
for (int i = 0; i < array.length; i++) {
System.out.print(" "+array[i]);
System.out.println(array);//地址值
}
数组作为方法返回值返回
1.任何数据类型都可以作为方法的参数类型或者返回值返回
2.数组作为方法的参数，传递进去的其实是数组的地址值
3.数组作为方法的返回值，传递进去的其实也是数组的地址值
public static int[] retrn_demo(int a ,int b ,int c ){
int sum = a+b+c;
int avg = sum/3;
int[] arr = new int[2];
arr[0] = sum;
arr[1] = avg;
return arr; //返回的是数组
------------------------------------------------------------------------------------------------------------------------
面向对象（！！！！！！！！！！！！！）
---------
面向过程思想：是面向对象的前身，实现一个功能时，更加看重过程，每一个步骤都要自身亲历亲为
---------
面向对象思想：实现一个功能的时候，不关心具体的步骤，而是找一个已经具有该功能的人来帮我做事
1.使用面向对象，有一个JDK提供了一个toString方法，直接能够把数组变成想要的字符串
2.将面向对象，将复杂进行简单性
三大特性：
1.封装性
类：一个具有相关属性和行为的集合
是对一类事物的描述，是抽象的
对象：是一类对象的实例，具体的
关系：类是对象的模板，对象是类的实体
属性：成员变量
行为：成员方法
关键注意：成员方法的特点是没有static关键字的！！！
成员变量可以写在类当中，作为全局变量
通常情况下，一个类不能够直接使用，而是需要创建一个对象才能够使用
1.导包(当所有类处于同一个包下面时，不必导入，可直接使用)
2.创建，格式()
类名 对象名 = new 类名()
Student stu = new Student()
3.使用，分为两种情况：
1.使用成员变量：对象名.成员变量
2.使用成员方法：对象名.成员方法()
(也就是，需要使用谁，就点谁)
当一个对象作为参数传递到方法当中时，实际传递进去的是对象的地址值
2.继承性
3.多态性
扫一扫
04-13
3585
3585
10-11
811
811
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
