第三课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 相应类型的值；
数组
-
声明、创建
-
遍历（使用）
-
修改
-
工具类
-
数组中保存固定量的值，声明数组时需要制定数组中元素的类型，数组的长度在创建数组时设定
-
特点：快速、有序、有效率地排列元素；通过位置索引
-
数组的声明
-
通用的一维数组的声明格式是：
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
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
-
专门用来拼接字符串的类
-
拼接过程中不创建新对象
-
节省内存，效率更高
-
-
区别
-
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]
}
}
浙公网安备 33010602011771号