学习Java入门基础

最新推荐文章于 2021-05-20 11:46:58 发布

Limeye

最新推荐文章于 2021-05-20 11:46:58 发布

阅读量226

点赞数

分类专栏： Java基础文章标签： Java

本文链接：https://blog.csdn.net/Limeye/article/details/84865823

版权

Java基础专栏收录该内容

14 篇文章 0 订阅

订阅专栏

Java从大的方面来说包括三个方向

1.j2se java语言基础
2.j2ee web方面（一般用来做网站，软件等）
3.j2me 手机编程(手机系统，手机java游戏等)
所有java程序内都是由一个个类来构成。
类中包括其自己的属性，方法等构成

标识符

作用

常量、变量、方法、类和包等的名称

命名规则

标识符可以由字母、数字、下划线（_）、美元符（$）组成，但不能包含 @、%、空格等其它特殊字符，不能以数字开头。譬如：123name 就是不合法滴；
标识符不能是 Java 关键字和保留字（ Java 预留的关键字，以后的升级版本中有可能作为关键字），但可以包含关键字和保留字。如：不可以使用 void 作为标识符，但是 Myvoid 可以；
标识符是严格区分大小写的。所以一定要分清楚 imooc 和 IMooc 是两个不同的标识符哦！
标识符的命名最好能反映出其作用，做到见名知意。

命名习惯

（1）类名：HelloWorld,每个单词首字母大写；
（2）变量名：helloWorld,第一个单词全小写，从第二个单词开始首字母大写；驼峰命名法；
（3）方法名：helloWorld(),第一个单词全小写，从第二个单词开始首字母大写；驼峰命名法；
（4）常量名：用final修饰的变量名：用HELLOWORLD,MAX_VALUE;全大写；
（5）包名：全小写：helloworld;

一、变量

计算机的内存类似于人的大脑，计算机使用内存来记忆大量运算时要使用数据。内存是一个物理设备，存储一个数据，把内存想象成一间旅馆，要存储的数据就好比要住宿的客人。

首先，旅店的服务人员会询问要住什么样的房间，如：单人间、双人间、总统套间；然后，根据选择的房间类型，服务员会安排合适的房间。“先开房间，后住”就描述了数据存入内存的过程。

首先，根据数据类型的类型为它在内存中分配一块空间（即找一个合适的房间），然后数据就可以放进这个空间（即入住）。

那么为什么对存储空间有要求呢？试想有3个客人，服务员就安排了一个人单人间，这能入住吗？分配的空间过小，会导致数据无法存储。

数据被存储在内存中，目的是便于在需要时取出来使用，或者如果这个数据被改变了，内存中存储的值也会随之相应的更新，以便下次使用新的数据。

变量是一个数据存储空间的表示

变量与房间的对应关系

旅馆中的房间	变量
房间名称	变量名
房间类型	变量类型
入住客人	变量的值

通过变量名可以简单快速的找到存储数据。将指定给变量，就是将数据存储到以别名为变量名的那个房间；调用变量，就是将那个房间中的数据取出来。可见，变量是存储数据的一个基本单元，不通的变量相互独立。

概念：

变量是指内存中的一个存储区域，该区域要有自己的名称（变量名）、类型（数据类型），该区域的数据可以在同一数据类型的范围内不断变化值；

变量的声明和使用

（1）声明变量，即“根据数据类型在内存重申请一块空间”，这里需要给变量名

语法：数据类型变量名

1 double score; //声明双精度浮点型变量score存储分数
2 String name; //声明字符串型变量name存储学生姓名
3 char sex; //声明字符型变量sex存储性别

（2）给变量赋值，即“将数据存储至对应的内存空间”

语法：变量名值

1 score = 98.5     //存储98.5
2 name = "张三"    //存储“张三”
3 sex = '男'       //存储‘男’

这样的分解步骤有点繁琐，也可以将步骤（1）（2）合二为一，在声明一个变量的同时给变量赋值。

语法：数据类型变量名 = 值

 1 double score = 98.5; 2 String name= "张三"; 3 char sex = '男';

（3）调用变量。使用存储的变量，我们称之为“调用变量”。

1 System.out.println(score);       //从控制台输出变量score存储的值
2 System.out.println(name);      //从控制台输出变量name存储的值
3 System.out.println(sex);         //从控制台输出变量sex存储的值

另外；理论上两种方法都各有好处。要注意的是“变量都必须声明和赋值之后才能使用”。

变量的使用注意事项：

Java中的变量必须声明后才能进行使用；

变量的作用域：在一对｛｝中为有效区间；

需要进行初始化后才能使用变量

（1）使用之前必须声明其数据类型，如：byte b=10;int i=10;

（2）变量不能重复声明

（3）变量在被赋初始值之后，变量值是可以改变的。

常量

所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。
final 常量名=值;
final double PI=3.14; final String LOVE=“imooc”;
常量名一般使用大写字符。
程序中使用常量可以提高代码的可维护性。例如，在项目开发时，我们需要指定用户的性别，此时可以定义一个常量 SEX，赋值为 “男”，在需要指定用户性别的地方直接调用此常量即可，避免了由于用户的不规范赋值导致程序出错的情况。

整型常量（默认int型）
浮点型常量（默认double）

数据类型

在这里插入图片描述

常见的Java数据类型

int 整型
用于存储整数，
例如，学生人数，某公司的员工编号、一年的天数，一天的小时数

double
双精度浮点型
用于存储带有小数的数字，例如，商品的价格、世界银行给其他国家的贷款金额、员工工资

char
字符型
用于存储单个字符，例如，性别’男’，‘女’、成绩’优’或’良’

String
字符串型
用于存储一串字符，例如，员工姓名、产品型号、产品的介绍信息

数值型

byte（8位/bit）short（2个字节）int（4个字节）
long（8个字节）long l=2599838388；

浮点类型

float（4个字节）double （8个字节）

字符型（char）

（1）单引号，必须只有一个字符
（2）对应的字符集Unicode，国际通用的字符集
（3）字符也可以用它的Unicode编码所代表的整数表示；

布尔型（boolean）

引用数据类型

类（class）
接口（interface）
数组

数据类型

在这里插入图片描述

常见的Java数据类型

int 整型
用于存储整数，
例如，学生人数，某公司的员工编号、一年的天数，一天的小时数

double
双精度浮点型
用于存储带有小数的数字，例如，商品的价格、世界银行给其他国家的贷款金额、员工工资

char
字符型
用于存储单个字符，例如，性别’男’，‘女’、成绩’优’或’良’

String
字符串型
用于存储一串字符，例如，员工姓名、产品型号、产品的介绍信息

数值型

byte（8位/bit）short（2个字节）int（4个字节）
long（8个字节）long l=2599838388；

浮点类型

float（4个字节）double （8个字节）

字符型（char）

（1）单引号，必须只有一个字符
（2）对应的字符集Unicode，国际通用的字符集
（3）字符也可以用它的Unicode编码所代表的整数表示；

布尔型（boolean）

引用数据类型

类（class）
接口（interface）
数组

运算符

优先级：单目>算数>关系>逻辑>三目>赋值

算术运算符

在这里插入图片描述
算术运算符主要用于进行基本的算术运算，如加法、减法、乘法、除法等。

赋值运算符

在这里插入图片描述
赋值运算符是指为变量或常量指定数值的符号。如可以使用 “=” 将右边的表达式结果赋给左边的操作数。

关系运算符

在这里插入图片描述
优先级：（>、<、>=、<=）大于（==、!=）

逻辑运算符

在这里插入图片描述

短路与&&：若左边为false，则不计算右边，整个表达式就是false;
短路或||：若左边为true，则不计算右边，整个表达式就是true.

位运算符

|、&、^、~
最高位：0代表正数，1代表负数
负数计算：（1）除符号位，其他数值位取反
（2）在取反的基础上加上1
（3）计算结果加上符号位

条件运算符

条件运算符（ ? : ）也称为 “三元运算符”。
语法形式：布尔表达式？表达式1 ：表达式2
运算过程：如果布尔表达式的值为 true ，则返回表达式1 的值，否则返回表达式2 的值

基本数据类型的类型转换

自动类型转换
强制类型转换

转换中的知识点

java中整数类型默认的int类型；小数类型默认的double；
char 可以当做一中特殊的整数类型；
int无法转换为boolean；
小数类型转为整数类型，小数可能被舍弃，所有出现精度损失，所以需要强制转换；
boolean 类型不能转换成任何其它数据类型；

方法

方法–就是用来解决一类问题的代码的有序组合，是一个功能模块。

访问修饰符  返回值类型 方法名(参数列表){
     方法体
}

访问修饰符：方法允许被访问的权限范围，可以是public、 protected、private甚至可以省略，其中public表示方法可以被其他任何代码调用。
返回值类型：方法返回值的类型，如果方法不返回任何值，则返回值类型指定为void;如果方法具有返回值，则需要指定返回值的类型，并在方法中使用return语句返回值
方法名：定义的方法的名字，必须使用合法的标识符
参数列表：传递给方法的参数列表，参数可以有多个，多个参数间以逗号隔开，每个参数由参数类型和参数名组成，以逗号隔开

方法的使用

调用方法—-当需要调用方法执行某个操作时，可以先创建类的对象，然后通过对象名.方法名()来实现；
1、无参无返回值
2、无参带返回值

注：

返回类型为void，方法中不能使用return 变量/常量；

方法的返回值最多只能有一个，不能返回多个值；

方法返回值类型必须兼容，例如，如果返回值类型为int,则不能返回String型值

3、带参无返回值

注：

我们把定义方法时的参数成为形式参数，目的是用来定义需要传入的参数的个数和类型；

把调用方法时的参数称为实参，是传递给方法真正被处理的值。

调用带参方法时，必须保证实参的数量、类型、顺序与形参一一对应

调用方法时，实参不需要指定数据类型

方法的参数可以是基本数据类型，如int、double等，也可以是引用数据类型，如String，数组等；

当方法参数有多个时，多个参数可以逗号隔开

4、带参带返回值

数组

数组概述：

1、数组可以看成是多个相同数据类型数据的组合，对这些数据的统一管理。

2、数组变量属引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量。

3、数组中的元素可以是任何类型，包括基本类型和引用类型。

数组对象的创建：

java中使用关键字new 创建数组对象，格式为：

数组名 = new 数组元素类型[数组元素个数]；

Java中对Array数组的常用操作

目录：

声明数组；
初始化数组；
查看数组长度；
遍历数组；
int数组转成string数组；
从array中创建arraylist；
数组中是否包含某一个值；
将数组转成set集合；
将数组转成list集合；
Arrays.fill()填充数组；
数组排序；
复制数组；
比较两个数组；
去重复；
查询数组中的最大值和最小值；

package MyTest01;
  
import java.util.*;
  
public class ArrayTest02 {


public static void main(String[] args) {
    //声明数组
    String [] arr;
    int arr1[];
      
    //初始化数组
    int arr2[]=new int[]{1,2,3,4,5};
    String[] array1={"马超","马云","关羽","刘备","张飞"};
    String[] array2=new String[]{"黄渤","张艺兴","孙红雷","小猪","牙哥","黄磊"};
      
    String[] array=new String[5];
  
      
    //查看数组的长度
    int length=array1.length;
    System.out.println("length：  "+array1.length);
      
    //输出数组
//      System.out.println(array1);     //结果：[Ljava.lang.String;@32f22097
        System.out.println("arr2:  "+Arrays.toString(arr2));
          
    //遍历数组
    for (int i = 0; i < array1.length; i++) {
//          System.out.println(array1[i]);
        }
        //int数组转成string数组
        int[]  array3={1,2,3,4,5,6,7,8,9,0};
        String arrStrings=Arrays.toString(array3);
//      System.out.println(arrStrings);
          
    //从array中创建arraylist
    ArrayList<String> arrayList=new ArrayList<String>(Arrays.asList(array1));
    System.out.println(arrayList);
      
    //数组中是否包含某一个值
    String a="马超";
    if (Arrays.asList(array1).contains(a)) {
        System.out.println("马超在这里");
    }
      
    //将数组转成set集合
    Set<String> set=new HashSet<String>(Arrays.asList(array2));
    System.out.println(set);
      
    //将数组转成list集合
    List<String> list=new ArrayList<String>();
    for (int i = 0; i < array2.length; i++) {
        list.add(array2[i]);
    }
    String[] arrStrings2={"1","2","3"};
    List<String > list2=java.util.Arrays.asList(arrStrings2);
    System.out.println(list2);
      
      
    //Arrays.fill()填充数组
    int[] arr3=new int[5];
    Arrays.fill(arr3, 10);  //将数组全部填充10
    for (int i = 0; i < arr3.length; i++) {
        System.out.println(arr3[i]);
    }
      
    //数组排序
    int[] arr4 = {3, 7, 2, 1, 9};
    Arrays.sort(arr4);
    for (int i = 0; i < arr4.length; i++) {
        System.out.println(arr4[i]);
    }
      
    int[] arr5 = {3, 7, 2, 1, 9,3,45,7,8,8,3,2,65,34,5};
    Arrays.sort(arr5, 1, 4);  //从第几个到第几个之间的进行排序
    for (int i = 0; i < arr5.length; i++) {
        System.out.println(arr5[i]);
    }
      
      
    //复制数组
    int[] arr6 = {3, 7, 2, 1};
    int[] arr7=Arrays.copyOf(arr6, 10);  //指定新数组的长度
      
    int[] arr8=Arrays.copyOfRange(arr6, 1, 3); //只复制从索引[1]到索引[3]之间的元素（不包括索引[3]的元素）
    for (int i = 0; i < arr8.length; i++) {
        System.out.println(arr8[i]);
    }
      
    //比较两个数组
    int[] arr9 = {1, 2, 3, 4,5,6,7,8,9,0};
    boolean arr10=Arrays.equals(arr6, arr9);
    System.out.println(arr10);
  
    //去重复
    //利用set的特性
    int[] arr11 = {1, 2, 3, 4,5,6,7,8,9,0,3,2,4,5,6,7,4,32,2,1,1,4,6,3};
    Set<Integer> set2=new HashSet<Integer>();
    for (int i = 0; i < arr11.length; i++) {
        set2.add(arr11[i]);
    }
        System.out.println(set2);
    int[] arr12 = new int[set2.size()];
    int j=0;
    for (Integer i:set2) {
        arr12[j++]=i;
    }
    System.out.println(Arrays.toString(arr12));
}  
  }




package MyTest01;
 
public class ArrayTest03 {


public static void main(String[] args) {
     
    int[] arr11 = {10, 2, 3, 4,5,6,7,8,9,0,3,2,4,5,6,7,4,32,2,1,1,4,6,3};
     //计算最大值
    int max = arr11[0];
    for (int i = 1; i < arr11.length; i++) {
         if (arr11[i] > max) {
             max = arr11[i];
        }
      }
      System.out.println("Max is " + max);
      //计算最小值
      int min = arr11[0];
      for (int i = 0; i < arr11.length; i++) {
        if (arr11[i]<min) {
            min = arr11[i];
        }
    }
      System.out.println("Min is " + min);
}
}

下面介绍一些API里面常见的对数组的操作

在java中，除java.lang包下的类和接口可以直接使用外，其他包下的类或接口在使用时需要先导包。

java.util.Arrays类:此类包含用来操作数组（比如排序和搜索）的各种方法。

这些都是静态方法，可以类名.方法名直接使用，这里都以int型数组为例

1、对数组进行快速排序

Arrays.sort(int[] arr);对传入的数组默认进行升序排序

2、返回指定数组内容的字符串表现形式。

Arrays.toString(int[] arr);

3、使用二分法搜索制定数组中的某个元素的下标

Arrays.binarySearch(int[] arr);

4、将将指定的 int 值分配给指定 int 型数组的每个元素。

Arrays.fill(int[] arr,int val);

5、复制指定的数组，截取或用 0 填充（如有必要），以使副本具有指定的长度。

Arrays.copyOf(int[] arr,int newLength);它的返回值是一个数组

6、将指定数组的指定范围复制到一个新数组。包含起始位置但不包含结束位置。

Arrays.copyOfRange(int[] arr,int from,int to);它的返回值是一个数组

Java流程控制包括顺序控制、条件控制和循环控制。

顺序控制，就是从头到尾依次执行每条语句操作。
条件控制，基于条件选择执行语句，比方说，如果条件成立，则执行操作A，或者如果条件成立，则执行操作A，反之则执行操作B。
循环控制，又称为回路控制，根据循环初始条件和终结要求，执行循环体内的操作。

顺序结构只能顺序执行，不能进行判断和选择，因此需要分支结构。

Java有两种分支结构：

if语句
switch语句

Java中有三种主要的循环结构：
while循环
do…while循环
for循环

if条件语句

使用if条件语句，可选择是否要执行紧跟在条件之后的那个语句。关键字if之后是作为条件的“布尔表达式”，如果该表达式返回true，则执行其后的语句；若为false，则不执行if后的语句。

　　 if（条件表达式）{ 执行语句； }

if···else语句

if···else语句是条件语句中最常用的一种形式，它会针对某种条件有选择的作出处理。通常表现为“如果满足某种条件，就进行某种处理，否则就进行另一种处理”。

if后的()内的表达式必须是boolean型的。如果为true，则执行if后的复合语句；如果为false，则执行else后的复合语句。

if（条件表达式）{    
	  执行语句；
 }else{
	执行语句；
  }

if···else if 多分支语句

if···else if多分支语句用于针对某一事件的多种情况进行处理。通常表现为“如果满足某种条件”，就进行某种处理，否则，如果满足另一种条件，则进行另一种处理。

 if（条件表达式）{
  执行语句；
 }else if（条件表达式）{          选择第一个满足条件的分支语句为分支入口；
   执行语句；
 }else{
  执行语句；
  }

switch多分支语句

switch语句是一种比较简单明了的多选一的选择，在Java语言中，可以用switch语句将动作组织起来进行多选一。

switch（表达式）{
 case 值：
	执行语句；
	 break；                             switch的表达式 只能是 byte、short、int、char；
 case 值：                           case的语句是无序的；case 的值同时加载到内存中；
	  执行语句；                          找到对应的case值作为程序入口，使用break语句来作为结束；
	  break；                                
 ……
 default：
	  执行语句；
	 break；（可以省略）
}

while循环语句

while循环语句的循环方式为利用一个条件来控制是否要继续反复执行这个语句。

 while（条件表达式）{
	  循环语句；
	}

do···while循环语句

do···while循环语句与while循环语句的区别是，while循环语句先判断条件是否成立再执行循环体，而do···while循环语句则先执行一次循环后，再判断条件是否成立。也即do···while至少执行一次。

do{
  	循环语句；
 }while（条件表达式）；

for循环语句

for循环语句是Java程序设计中最有用的循环语句之一。一个for循环可以用来重复执行某条语句，知道某个条件得到满足。

for循环的执行顺序：首先执行初始化表达式，判断循环条件，如果条件返回值为true，执行循环语句，然后执行循环后表达式，再次判断循环条件……

 for（初始化表达式；条件表达式；循环后表达式）{
  循环语句；
}

foreach语句

Java5引入了一种主要用于数组的增强型for循环。

语法

　for (声明语句 : 表达式) {
 　   //代码句子
　}

声明语句：声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。

表达式：表达式是要访问的数组名，或者是返回值为数组的方法。

跳转语句

Java语言提供了三种跳转语句，分别是break语句、continue语句和return语句。

1. break语句

break语句刚刚在switch中已经见过了，是用来中止case的。实际上break语句在for、while、do···while循环语句中，用于强行退出当前循环，为什么说是当前循环呢，因为break只能跳出离它最近的那个循环的循环体，假设有两个循环嵌套使用，break用在内层循环下，则break只能跳出内层循环
　　1、break必须使用在switch或者循环语句中；
　　2、在switch或循环语句中，break单独使用时，下面不允许有代码语句；
　　3、默认情况下，break只能跳出语句所属的最近一层循环；

continue语句

continue语句只能用于for、while、do···while循环语句中，用于让程序直接跳过其后面的语句，进行下一次循环。

return语句

return语句可以从一个方法返回，并把控制权交给调用它的语句。

Limeye

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
学习Java入门基础

Java 入门基础知识数据类型基本数据类型数值型byte（8位/bit）short（2个字节）int（4个字节）long（8个字节）long l=2599838388；浮点类型float（4个字节）double （8个字节）字符型（char）（1）单引号，必须只有一个字符（2）对应的字符集Unicode，国际通用的字符集（3）字符也可以用它的Unicode编码所代表的...
复制链接

扫一扫