第三课Java编程基础

关键字与表示符

具体命名规范

• 变量（小驼峰）###

• 使用名词
• 由一个单词组成时全部小写
• 变量名有多个单词组成时

• 第一个单词的首字母小写
• 后续单词的首字母大写
• 其余字母小写

• 常量

• 常量名全部大写
• 格式如下
  public static final int COLOR_RED = 1;

• 类名（大驼峰）

• 使用名词
• 由一个单词组成时首字母要大写
• 有多个单词组成时

• 每个单词的首字母大写
• 其余字母小写

• 方法名

• 方法使用动词或动宾词组
• 由一个单词组成时全部小写
• 有多个单词组成时

• 第一个单词的首字母小写
• 其余单词的首字母大写
• 其余字母小写

基本数据类型

java的变量类型

原始数据类型

• Java是强类型语言
• 8种原始数据类型

• 四种整数类型（byte \ short \ int \ long）
• 两种浮点数类型（float \ double)
• 一种字符类型（char）
• 一种布尔类型（Boolean）

整型数据类型

运算符程序控制流程

• 顺序结构

• 程序中的语句都是按照在代码中出现的先后顺序执行的

• 选择结构

• if
• if-else-else
• switch

• 循环结构

• while
  while（条件表达式）{
  执行语句
  }
• do while

• do while循环中while后有分号
• 总是先执行循环体，然后再计算条件表达式
  do{
  执行语句
  }while（条件表达式）;

• for
  for(变量初始化；条件；增量表达式){
  执行语句
  }

break

 

continue

方法简述

方法定义的格式

• 定义方法的完整格式：
  修饰符 返回值类型 方法名称 （参数类型 参数名称， ...）{
  方法体
  return 返回值；
  }
• 定义方法的三要素
  返回值类型、方法名称、参数列表
• 方法的三种调用格式
  单独调用、打印调用、赋值调用

方法

 

---

当方法声明为void时，使用return；语句，或者不写

局部变量

• 在方法或代码块中定义的变量
• 局部变量在使用前必须赋值
• 超出定义的作用域，就不能再访问局部变量
• 不能在变量的作用域中重复声明变量

局部变量的作用域

一对大括号的范围

<!--for循环中声明语句的变量的作用域为整个for循环-->

参数变量

• 在方法名中声明的变量
• 在整个方法体内可用
  public class Test Class{
  public static void main(String[] args){
  System.out.println("Hello world");
  }
  }

---

方法的返回——return

return

• 当返回类型为void时
  return； 或者不写
• 其他情况-必须写
  return 相应类型的值；

数组

2. 声明、创建
3. 遍历（使用）
4. 修改
5. 工具类

• 数组中保存固定量的值，声明数组时需要制定数组中元素的类型，数组的长度在创建数组时设定
• 特点：快速、有序、有效率地排列元素；通过位置索引

数组的声明

• 通用的一维数组的声明格式是：
  type[] var-name;
• 举例：
  int[] x;
  <!--在Java中声明数组时不能指定其长度。-->
  <!--这种定义是非法的：int a[5];-->

创建数组

利用new来为数组型变量分配内存空间

x = new int[100];

x = null;

声明 + 赋值 ：int[] x = new int[100];

不要超出可用内存范围

动态初始化： 数组类型[] 数组名称 = new 数据类型[数组长度];

静态初始化： 数组类型[] 数组名称 = new 数据类型[]{元素1，元素2，元素3...};

静态初始化省略格式： 数组类型[] 数组名称 = {元素1，元素2，元素3...};

数据类型的默认值

数组长度

• length属性表示数组的长度
  int[] a = new int[5];
  int length = a.length;

访问数组元素

• 传统方式
  int[] anArray = {1,2,3,4};
  for(int i = 0;i <= anArray.length;i++){
  System.out.println("element" + (i+1) + "is" + anArry[i]);
  }
   
• JDK1.5中对for语句的改进
  int[] anArray = {1,2,3,4};
  for(int element : anArray){
  System.out.println("element" + element);
  }

数组下标从0开始，从c[0]就是第一个元素，第i个元素是c[i-1];

数组下标可以为常数或表达式

数组赋值

int[] anArray = {37,47,23,-5,19,56};

int[] anotherArray;

anotherArray = anArray;

anotherArray[3] = 77;

数组拷贝

• copy前需要先创建一个空数组
• 调用此方法的效率比直接使用for循环对元素进行复制效率高

Java.util.Arrays

• 用于操作数组的工具类
• 提供大量方法

• 排序Arrays.sort
  对数组进行排序，方法调用完成后，数组按升序排列
• 二分查找Arrays.binarySearch
  对数组进行二分查找之前，数组必须已经进行过排序
  没有查找到对应的数组下标，返回一个负数
• 填充值Arrays.fill

一直数组中的元素为

-5,19,23,37,47,56

如何将新元素35插入到数组中，并使数组保持原顺序

package com.cqyt.stx.level01.work;

public class Page141 {

public static void main(String[] args) {

int[] oldArray = {-5,19,23,37,47,56};

//创建一个新的数组，长度为旧的数组长度+1

int[] newArray = new int[oldArray.length+1];

//1.将插入点之前的元素拷贝到新数组

for(int index = 0;index < 3;index++){

newArray[index] = oldArray[index];

}

//2.插入新的元素

newArray[3] = 35;

//3.将插入点之后的元素拷贝到新数组

for(int index = 4;7 > index ;index++){

newArray[index] = oldArray[index - 1];

}

printArray(oldArray);

printArray(newArray);

}

public static void printArray(int[] arr){

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

System.out.print(arr[index] + ",");

}

System.out.println();

}

}

package com.cqyt.stx.level01.work;

import java.util.Arrays;

public class Page141_01 {

public static void main(String[] args) {

int[] oldArray = {-5,19,23,37,47,56};

//从oldArray数组中查找35

int indexs = Arrays.binarySearch(oldArray,35);

int[] newArray = new int[oldArray.length+1];

System.out.println(indexs);

//1.将插入点之前的元素拷贝到新数组

for(int index = 0;index < 3;index++){

newArray[index] = oldArray[index];

}

//2.插入新的元素

newArray[-indexs-1] = 35;

//3.将插入点之后的元素拷贝到新数组

for(int index = 4;7 > index ;index++){

newArray[index] = oldArray[index - 1];

}

System.out.println(Arrays.toString(oldArray));

System.out.println(Arrays.toString(newArray));

}

}

java.util.Arrays.to.String()

返回指定数组内容的字符串表示形式

字符串

创建字符串

• 不使用new的方式
  String prompt = "Hello Word";
  从字符串池中查找，如果字符串池中没有，则在字符串池中创建
• 使用new的方式
  String prompt = new String("Hello World");
  每次创建一个新的对象

字符串是有字符组成的序列。

在Java中字符用一个类来表示，创建一个字符串相当于创建这个类的一个实例。

在Java中创建对象一般需要使用关键字new

字符串池

程序当中直接写上的双引号字符串，就在字符串常量池中。

new的不在常量值中。

String字符串的不变性

• 字符串一旦创建，任何方法都不能修改其内容

• 对于对象的所有操作都不能改变原来对象
• 在对象的整个生存周期内固定不变

==和equals

• ==

• 比较两个对象的地址是否相同

• equals()

• 比较当前对象的值是否和另一字符串一致

• equals sIgnoreCase

• 不区分大小写比较两个比较当前对象的值是否和另一字符串一致

对基本类型来说，==是进行数值的比较

对引用类型来说，==是进行地址值的比较

字符串的拼接

String a = "test";

String b = "3";

String c = a + b; //test3

String d = "test" + "3";  //test3

String e = a + 2 + 1; //test21

String f = a + (2 + 1); //test3

String g = a.concat("3"); //test3

拼接格式化字符串

String.format

print

package com.cqyt.stx.level01.string;

public class Demo01 {

public static void main(String[] args) {

//创建字符串对象

String str1 = "Hello";

String str2 = "Hello";

System.out.println(str1 == str2);   //true

System.out.println(str1.equals(str2));     //true

str2 = "World";

System.out.println(str2);   //World

System.out.println(str1 == str2);   //false

String str3 = str2.replace("0","f");

System.out.println("str3:"+ str3);  //world

System.out.println("str2:" + str2); //world

System.out.println("===============");

String str4 = "问天一部";

System.out.println(10 + 20 + str4); //30问天一部

System.out.println(str4 + 10 + 20); //问天一部1020

}

}

String字符串的不变性

 

字符串的常用操作

package com.cqyt.stx.level01.string;

/**

* 字符串的常用操作

*/

import java.util.Arrays;

public class Demo02 {

public static void main(String[] args) {

toCharArrayDemo();

charAtDemo();

substringDemo();

indexof();

}

public static void indexof() {

String str = "问天一部666";

int index = str.indexOf("部666");

System.out.println("部666的index:" + index);

}

public static void substringDemo() {

String str = "问天一部666";

String substring = str.substring(3);

System.out.println(substring);

String substring1 = str.substring(0, 4);

System.out.println(substring1);

String substring2 = str.substring(4, 7);

System.out.println(substring2);

}

public static void charAtDemo() {

String str = "问天一部666";

char c = str.charAt(0);

System.out.println(c);

}

private static void toCharArrayDemo() {

//toCharArray

String str = "问天一部666";

//str.toCharArray();

char[] chars = str.toCharArray();

//使用for循环遍历数组

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

System.out.print(chars[i]);

}

//打印数组的第二种方式：使用Arrays.toString方法

String s = Arrays.toString(chars);

System.out.println(s);

}

}

转换符

package com.cqyt.stx.level01.string;

public class Demo03 {

public static void main(String[] args){

//将int型转换为16进制

int ch = '我';   //自动类型转换

String s = Integer.toHexString(ch);

System.out.println(s);

System.out.printf("我的十六进制是%x",ch);

}

}

StringBuffer和StringBuilder

已学的类：Scanner \ Arrays \ String \ System

• 专门用来拼接字符串的类

2. 拼接过程中不创建新对象
3. 节省内存，效率更高

• 区别

• StringBuilder：非线程安全

• 作为局部变量是使用

• StringBuffer：线程安全

• 作为类成员变量是使用

package com.cqyt.stx.level01.string;

public class Demo04 {

public static void main(String[] args) {

int[] arr = {19, 22, 33, 11, 58};

// 创建一个StringBuilder的对象，对象名称是sb

StringBuilder sb = new StringBuilder();

sb.append("[");

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

sb.append(arr[index]);

if(index == arr.length -1){

sb.append("]");

}else{

sb.append(",");

}

}

//通过toString方法返回字符串表现

String s = sb.toString();

System.out.println(s);

}

}

字符串与其他类型相互转换

包装类

byte Byte

short Short

int Integer

long Long

float Float

double Double

char Character

boolean Boolean

命令行参数（理解）

方法调用中的参数传递

public class Work_22_03 {

public static void main(String[] args) {

Work_22_03 param = new Work_22_03();

String s =""; //初始化字符串s

StringBuffer buffer = new StringBuffer(""); //初始化拼接字符串buffer

String[] strings = new String[1]; //初始化字符串数组strings 并定义数组下标至1

strings[0] = "";  //数组string[0] 赋值为空

int n = 0;   //初始化n 并赋值等于1

int[] numbers = new int[]{0}; //初始化数组numbers 并添加一个元素0

param.increase(n);

param.increase(numbers);

param.append(s);

param.append(buffer);

param.append(strings);

}

public void increase(int n) {

n++;

System.out.println(n); //1  参数n 进行自增后输出

}

public void increase(int[] nums) {

nums[0]++;

System.out.println(Arrays.toString(nums));   //[1]  调用参数 nums = numbers 并使数组numbers[0]自增 为1

}

public void append(String s) {

s += 1;

System.out.println(s);  // 1  字符串s 进行加法运算 s = 0 + 1 = 1

}

public void append(StringBuffer s) {

s.append(1);  //为字符串buffer 添加数值1

System.out.println(s);  //1

}

public void append(String[] strings) {

strings[0] += 1;  //字符串数组String[0] + 1 = 1

System.out.println(Arrays.toString(strings));    //[1]

}

}