Java编程思想学习笔记

命名：

驼峰命名法

类： 大驼峰 首写字母大写 FirstSample

变量 文件 文件夹 方法 ： 小驼峰 首字母小写 firstSample

常量 用 staic final 修饰 保证能被所以线程共享使用 且不能更改 命名 全大写 FIRSTSAMPLE

注释：

写代码时要注意注释

---

作者邮箱

标明类的作用

时间

作者

上次修改日期

方法注释

---

方法作用

作者

邮箱

时间

入参说明

出参说明

方法内部注释

---

方法内部打印入参值 + 用户ID

执行代码‘

打印出参值

return

数据类型

          Java是一种强类型语言，每一个变量都需要声明其类型。

          Java八种基本类型 ： 

          整型： byte    short    int   long

          浮点型 ： float  double 

          字符型 ： char

          布尔型 ： boolean 

          基本类型的存储需求

           首先引出 bit ，bit是信息存储是的最小单位，一bit就是我们常说的一位，更形象的解释是在我们使用二进制时的一个1或一个0他们的存储单位就是bit

         整数类型的存储（取值范围是怎么得来的会在位运算部分有解释）

          1byte（字节）为 8bit      取值范围 为 -128 ~ 127

           1 short 为 16 bit 2字节   取值范围 为 -32768 ~ 32767 

           1 int 为 32bit 4字节         取值范围 为-2147483648~2147483647 

           1 long 为 64 bit 8字节     取值范围 为 -9223372036854775808~9223372036854775807

          浮点类型的存储

            

           为什么float存储空间是字节但表示范围比int long 都要大？

       首先：float的存储方式是

  

     符号位     阶位                          数值位

                        x                                  y

存储方式是

符号  (2^（x-127）)*y

这种存储方式丧失大量的精度，其有效表示位数为6-7位

所以float是以丧失精度来实现的更大的表示范围。

int 与float的范围比较

在一定范围内float的精度是比int高的，他可以精确到小数位，距离零越近他表示的就越精确，

而int只能表示整数，丧失的精度一直为1，而到数值较大的时候float丧失的精度会很大，此时int的精度会更高。

 注：基本数据类型都是有精度缺失的，是不可靠的

double类型是 1  11  52

char类型：

字符类型在计算机中存的是他的编码值

boolean 类型

boolean 类型有两个值 ：false 和 true  ，boolean类型和整数类型不能进行相互转换

类型转换

其中int类型数据转为float类型会损失精度，而转换成double不会，因为double的数值位可以容纳下32位的int类型

变量与常量

变量

java声明变量的方式  type  name = value；

type是指变量的类型，java中每个变量都有一个类型

name指变量名

变量初始化： 对变量进行第一次赋值

value指对变量进行赋值，声明变量后必须用赋值语句对变量进行显示的初始化，不要使用未初始化的变量。

 常量

java中final指示常量

final修饰的变量只能被赋值一次（final关键字的作用在final关键字部分有解释）

常量名 习惯使用全大写

如果需要某个常量在一个类的多种方法下使用，通常将这些常量称为 类常量 用 static final 修饰

同时可以设置为public供所有类使用

运算符

基本运算符 

+ 加法

- 减法

*  乘法

/ 除法

% 取余

数值间的类型转换（自认为挺重要的）

当对两个数值进行二元操作时需要进行类型转换操作：

•如果两个操作数中有一个是 double 类型， 另一个操作数就会转换为 double 类型。

•否则，如果其中一个操作数是 float 类型，另一个操作数将会转换为 float 类型。

•否则， 如果其中一个操作数是 long 类型， 另一个操作数将会转换为 long 类型。

•否则， 两个操作数都将被转换为 int 类型。

赋值与运算符的结合：

 

x+=4

即x = x+4

自增自减运算符

自增  n++  ++n

自减  n--  --n

n++ 与 ++n的区别

n++ 是先赋值，再进行自增的操作

++n是先自增，再进行赋值

  int n= 1;
  System.out.println(n++);

会输出 1
   而
  System.out.println(++n);
输出2

关于自增运算的陷阱

int x=1; x =++x; System.out.println(x);

输出为 1

x= x++;

和 x++中的等号是有冲突的

只会有前边的=执行

int x=1; x =++x; System.out.println(x);

输出为2

这个先执行++x中的=号

前边的=号是不会执行的

一些关系和boolean运算符

== 对于基本数据类型来说判断的是数值的大小（==的作用会在与equals对比时有具体的说明）

!=  不等于

< 小于   > 大于  <=小于等于  >=大于等于

&& 与   || 或  

三元操作符：

条件  ？ 第一个表达式：第二个表达式

举个例子：

int a= 1;
int b= 2;
System.out.println(a>b?a:b);

输出 2

位运算

计算机里只有加法运算 位运算左移右移分别代表乘除2的n次方(当然对于x进制数代表x的n次方，下边都以二进制为例)

移位运算的速度很快

cpu 里用的是拆分运算 如

左移运算 从右往左推右边空出来的部位用0来代替  左移纪委就是乘2的几次幂

右移几位就是除以2的几次幂 对于右移运算来说需要区分正负，左边空出来的位需要用0或1填补 正数用0 负数用1

与 或 非 位运算

& （and） 按位与操作 ： 两个操作数 相同为1则为 1，否则为0

| （or） 按位或操作 ：两个操作数 相同为0则为 0，否则为1

~（not） 按位取反

^(xor) 按位异或操作 两个操作数 相同为 0，不同则为1

例子：

   11110110

& 00001000

------------------

   00000000

  11110110

| 00001000

------------------

  11111110

   11110110

^ 00001000

------------------

  11110110

字符串

字符串的拼接：

  java使用+号实现对字符串的拼接，字符串相加就意味着字符串的拼接

当一个字符串与另一个非字符串的值拼接时分字符串的值会转成字符串

不可变字符串：

不能在原地址对字符串进行修改，需要新开辟空间去存放修改后的字符串。

不能再原地址修改值

只能开辟新空间然后指过去

当我们进行拼接等操作时都是在字符串常量池或堆中新开一个地址去接受新的值，原字符串不会受到影响。

检测字符串是否相等

s.equals()  java常用这个方法来检测两个字符串的值是否相同

null串 和""（空串）

空串是一个java对象串长度为0，内容为空 我们可以对他使用length（）方法来检测他的长度

而空串只没有对象和这个变量关联

码点

码点就是编码值

字符串的存储

string a ="asd";

string b ="asd";

string c =new string("asd")

一些String可能用到的方法：

subString

---

equals

---

可用来判断子串，是子串输出正数，不是则输出一个负数

length（）

输出字符串的长度

•

String trim( ) 返回一个新字符串。这个字符串将删除了原始字符串头部和尾部的空格

字符串的构建：

String和Stringbuilder和StringBuffer的区别

后两者比较string在构建字符串时要快很多

内存里边一个4kb只能放一个变量，新申请浪费太大 一个变量至少消耗一个存贮空间，占据内存过大会新开空间

string字符串是不变字符串（内部是由数组实现的，数组是连续的且大小不可变，当我们需要更改字符串的时候必须去新开一个数组），每进行一次增加就需要新申请一个存储单元，而stringbuilder能在原地址不断增加直到存储单元存满以后才去开一个新的存储单元

StringBuilder 类。 这个类的前身是 StringBuffer, 其效率稍有些

低， 但允许采用多线程的方式执行添加或删除字符的操作

如果所有字符串在一个单线程中编辑 （通常都是这样 )，

则应该用 StringBuilder 替代它。 这两个类的 APi是相同的。

多线程下StringBuffer比较安全，因为里边加了锁

输出时需要通过toString方法转换成字符串

输入

首先 Scanner  in = new Scanner (System.in);

然后 in 调用  nextInt 和 nextLine 方法

控制流程

块作用域

{

      int n

}

用来控制变量的作用范围

条件语句

if语句

if（）{

}

判断（）中的内容确定下一步要执行的命令

循环语句

for 循环 

for（）{

}

根据（）中的条件进行循环

for each循环

for（int i:data）{

System.out.println(i);

}

i 依次代表data中的数据，每一次循环输出一个i，好处不用考虑数组越界的情况。

while循环

whilie（）{}

根据（）中的内容，不断地进行循环

多重选择 switch

直接上代码：

public class Main {

  public static void main(String[] args) {
    Scanner in=new Scanner(System.in);
    Scanner ins=new Scanner(System.in);
    int age= in.nextInt();
    int sa = ins.nextInt();
    switch (age){
      case 0:
        sa+=200;
        System.out.println("您目前工作了0年，基本工资为3000，应涨工资200，涨后工资"+sa);
        break;
      case 1:
        sa+=500;
        System.out.println("您目前工作了1年，基本工资为3000，应涨工资500，涨后工资"+sa);
        break;
      case 2:
        sa+=500;
        System.out.println("您目前工作了2年，基本工资为3000，应涨工资500，涨后工资"+sa);
        break;
      case 3:
        sa+=1000;
        System.out.println("您目前工作了3年，基本工资为3000，应涨工资1000，涨后工资"+sa);
        break;
      case 4:
        sa+=1000;
        System.out.println("您目前工作了4年，基本工资为3000，应涨工资1000，涨后工资"+sa);
        break;
      case 5:
        sa+=2500;
        System.out.println("您目前工作了5年，基本工资为3000，应涨工资2500，涨后工资"+sa);
        break;
      case 6:
        sa+=2500;
        System.out.println("您目前工作了6年，基本工资为3000，应涨工资2500，涨后工资"+sa);
        break;
      case 7:
        sa+=2500;
        System.out.println("您目前工作了7年，基本工资为3000，应涨工资2500，涨后工资"+sa);
        break;
      case 8:
        sa+=2500;
        System.out.println("您目前工作了8年，基本工资为3000，应涨工资2500，涨后工资"+sa);
        break;
      case 9:
        sa+=2500;
        System.out.println("您目前工作了9年，基本工资为3000，应涨工资2500，涨后工资"+sa);
        break;
      case 10:
        sa+=5000;
        System.out.println("您目前工作了10年，基本工资为3000，应涨工资5000，涨后工资"+sa);
        break;
      case 11:
        sa+=5000;
        System.out.println("您目前工作了11年，基本工资为3000，应涨工资5000，涨后工资"+sa);
        break;
      case 12:
        sa+=5000;
        System.out.println("您目前工作了12年，基本工资为3000，应涨工资5000，涨后工资"+sa);
        break;
      case 13:
        sa+=5000;
        System.out.println("您目前工作了13年，基本工资为3000，应涨工资5000，涨后工资"+sa);
        break;
      case 14:
        sa+=5000;
        System.out.println("您目前工作了14年，基本工资为3000，应涨工资5000，涨后工资"+sa);
        break;

  }}}

一个简单地根据工作时长判断工资的例子。

continue 和 break

break 是直接跳出这个循环执行下一步操作

continue越过剩下的循环部分，重新进入循环

数组

  数组的声明方式 ：int [] arr = new int [length]

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

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

数组在内存中的存储

只存头元素的地址。 

声明一个三维数组

   int [][][] arr ={
       {{1,2,3},{67}},
       {{4,5,6},{7,8}}
   };

遍历这个数组：

  for (int a[][]:arr) {
      for (int b[]: a) {
        for (int c:b) {
          System.out.println(c);
        }
      }
    }

三维数组在内存中的存储：

数组排序 

Arrays.sort（arr）方法用来给数组排序