Java 第8天 String类、static关键字、Arrays类、 Math类

最新推荐文章于 2024-04-03 21:22:15 发布
最新推荐文章于 2024-04-03 21:22:15 发布
阅读量119 收藏
点赞数
分类专栏： java学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44354035/article/details/107815090
版权

String类、static关键字、Arrays类、 Math类

第一章 String类

1.1 String类概述

概述

java.lang.String 类代表字符串。Java程序中所有的字符串文字（例如 “abc” ）都可以被看作是实现此类的实 例。

类 String 中包括用于检查各个字符串的方法，比如用于比较字符串，搜索字符串，提取子字符串以及创建具有翻 译为大写或小写的所有字符的字符串的副本。

特点

  1. 字符串不变：字符串的值在创建后不能被更改。
String s1 = "abc"; 
s1 += "d"; 
System.out.println(s1); // "abcd" 
// 内存中有"abc"，"abcd"两个对象，s1从指向"abc"，改变指向，指向了"abcd"。
  1. 因为String对象是不可变的，所以它们可以被共享
String s1 = "abc"; 
String s2 = "abc"; // 内存中只有一个"abc"对象被创建，同时被s1和s2共享。

个人观点 相当于省略 
			String s1=new String();  	
			String s2=new String();
		再将“abc”赋值给 s1、s2
  1. “abc” 等效于 char[] data={ ‘a’ , ‘b’ , ‘c’ }
例如： 
String str = "abc"; 

相当于： 
char data[] = {'a', 'b', 'c'}; 
String str = new String(data);
 // String底层是靠字符数组实现的。

1.2 使用步骤

  • 查看类java.lang.String ：

    • 此类不需要导入。

  • 查看构造方法

    • public String() ：初始化新创建的 String对象，以使其表示空字符序列。

    • public String(char[] value) ：通过当前参数中的字符数组来构造新的String。

    • public String(byte[] bytes) ：通过使用平台的默认字符集解码当前参数中的字节数组来构造新的 String。

构造举例，代码如下：

// 无参构造 
String str = new String（）； 

// 通过字符数组构造 
char chars[] = {'a', 'b', 'c'}; 
String str2 = new String(chars); 

// 通过字节数组构造 
byte bytes[] = { 97, 98, 99 }; 
String str3 = new String(bytes);

1.3 常用方法

判断功能的方法

  • public boolean equals (Object anObject) ：将此字符串与指定对象进行比较。
  • public boolean equalsIgnoreCase (String anotherString) ：将此字符串与指定对象进行比较，忽略大小 写。

方法演示，代码如下：

public class String_Demo01 { 
	public static void main(String[] args) { 
		// 创建字符串对象 
		String s1 = "hello"; 
		String s2 = "hello"; 
		String s3 = "HELLO"; 
		
		// boolean equals(Object obj):比较字符串的内容是否相同 
		System.out.println(s1.equals(s2)); // true 
		System.out.println(s1.equals(s3)); // false 
		System.out.println("‐‐‐‐‐‐‐‐‐‐‐"); 
		
		//boolean equalsIgnoreCase(String str):比较字符串的内容是否相同,忽略大小写 
		System.out.println(s1.equalsIgnoreCase(s2)); // true 
		System.out.println(s1.equalsIgnoreCase(s3)); // true 
		System.out.println("‐‐‐‐‐‐‐‐‐‐‐"); 
	} 
}

Object 是” 对象”的意思，也是一种引用类型。作为参数类型，表示任意对象都可以传递到方法中。

获取功能的方法

  • public int length () ：返回此字符串的长度。
  • public String concat (String str) ：将指定的字符串连接到该字符串的末尾。
  • public char charAt (int index) ：返回指定索引处的 char值。
  • public int indexOf (String str) ：返回指定子字符串第一次出现在该字符串内的索引。
  • public String substring (int beginIndex) ：返回一个子字符串，从beginIndex开始截取字符串到字符 串结尾。
  • public String substring (int beginIndex, int endIndex) ：返回一个子字符串，从beginIndex到 endIndex截取字符串。含beginIndex，不含endIndex。

方法演示，代码如下：

public class String_Demo02 { 
	public static void main(String[] args) { 
		//创建字符串对象 
		String s = "helloworld"; 
		
		// int length():获取字符串的长度，其实也就是字符个数 
		System.out.println(s.length()); 
		System.out.println("‐‐‐‐‐‐‐‐"); 
		
		// String concat (String str):将将指定的字符串连接到该字符串的末尾. 
		String s = "helloworld"; 
		String s2 = s.concat("**hello itheima");
		System.out.println(s2);// helloworld**hello itheima 
		
		// char charAt(int index):获取指定索引处的字符
		System.out.println(s.charAt(0)); 
		System.out.println(s.charAt(1)); 
		System.out.println("‐‐‐‐‐‐‐‐"); 
		
		// int indexOf(String str):获取str在字符串对象中第一次出现的索引,没有返回‐1 
		System.out.println(s.indexOf("l")); 
		System.out.println(s.indexOf("owo")); 
		System.out.println(s.indexOf("ak")); 
		System.out.println("‐‐‐‐‐‐‐‐"); 
		
		// String substring(int start):从start开始截取字符串到字符串结尾 
		System.out.println(s.substring(0)); 
		System.out.println(s.substring(5)); 
		System.out.println("‐‐‐‐‐‐‐‐"); 
		
		// String substring(int start,int end):从start到end截取字符串。含start，不含end。 
		System.out.println(s.substring(0, s.length())); 
		System.out.println(s.substring(3,8)); 
	} 
}

转换功能的方法

  • public char[] toCharArray () ：将此字符串转换为新的字符数组。
  • public byte[] getBytes () ：使用平台的默认字符集将该 String编码转换为新的字节数组。
  • public String replace (CharSequence target, CharSequence replacement) ：将与target匹配的字符串使 用replacement字符串替换。

方法演示，代码如下：

public class String_Demo03 { 
	public static void main(String[] args) { 
		//创建字符串对象 
		String s = "abcde"; 
		
		// char[] toCharArray():把字符串转换为字符数组 
		char[] chs = s.toCharArray(); 
		for(int x = 0; x < chs.length; x++) { 
			System.out.println(chs[x]); 
		}
		System.out.println("‐‐‐‐‐‐‐‐‐‐‐"); 
		
		// byte[] getBytes ():把字符串转换为字节数组 
		byte[] bytes = s.getBytes(); 
		for(int x = 0; x < bytes.length; x++) { 
			System.out.println(bytes[x]); 
		}
		System.out.println("‐‐‐‐‐‐‐‐‐‐‐"); 
		
		// 替换字母it为大写IT
		String str = "itcast itheima"; 
		String replace = str.replace("it", "IT"); 
		System.out.println(replace); // ITcast ITheima 
		System.out.println("‐‐‐‐‐‐‐‐‐‐‐"); 
	} 
}

CharSequence 是一个接口，也是一种引用类型。作为参数类型，可以把String对象传递到方法中。

分割功能的方法

public String[] split(String regex) ：将此字符串按照给定的regex（规则）拆分为字符串数组。 方法演示，代码如下

public class String_Demo03 { 
	public static void main(String[] args) { 
		//创建字符串对象 
		String s = "aa|bb|cc"; 
		String[] strArray = s.split("|"); // ["aa","bb","cc"] 
		for(int x = 0; x < strArray.length; x++) { 
			System.out.println(strArray[x]); // aa bb cc 
		} 
	} 
}

1.4 String类的练习

拼接字符串

定义一个方法，把数组{1,2,3}按照指定个格式拼接成一个字符串。格式参照如下：

	[word1#word2#word3]。

public class StringTest1 { 
public static void main(String[] args) { 
//定义一个int类型的数组 
int[] arr = {1, 2, 3}; 

//调用方法 
String s = arrayToString(arr); 

//输出结果 
System.out.println("s:" + s); 
}

/* 
* 写方法实现把数组中的元素按照指定的格式拼接成一个字符串 
* 两个明确：
* 返回值类型：String 
* 参数列表：int[] arr 
*/ 

public static String arrayToString(int[] arr) { 
	// 创建字符串s
	String s = new String("["); 
	// 遍历数组，并拼接字符串 
	for (int x = 0; x < arr.length; x++) { 
			if (x == arr.length ‐ 1) { 
				s = s.concat(arr[x] + "]"); 
			} else { 
				s = s.concat(arr[x] + "#"); 
			} 
		}
		return s; 
	} 	
}

统计字符个数

键盘录入一个字符，统计字符串中大小写字母及数字字符个数

public class StringTest2 { 
	public static void main(String[] args) { 
		//键盘录入一个字符串数据 
		Scanner sc = new Scanner(System.in); 
		System.out.println("请输入一个字符串数据："); 
		String s = sc.nextLine(); 
		
		//定义三个统计变量，初始化值都是0 
		int bigCount = 0; 
		int smallCount = 0; 
		int numberCount = 0; 
		
		//遍历字符串，得到每一个字符 
		for(int x=0; x<s.length(); x++) { 
			char ch = s.charAt(x); 
		
			//拿字符进行判断 
			if(ch>='A'&&ch<='Z') { 
			
			bigCount++; 
			
			}else if(ch>='a'&&ch<='z') { 
			
			smallCount++; 
			
			}else if(ch>='0'&&ch<='9') { 
			
			numberCount++; 
			
			}else { 
			
			System.out.println("该字符"+ch+"非法"); 
			
			} 
		}
		
		//输出结果 
		System.out.println("大写字符："+bigCount+"个"); 
		System.out.println("小写字符："+smallCount+"个"); 
		System.out.println("数字字符："+numberCount+"个"); 
	} 
}

第二章 static关键字

2.1 概述

static 关键字可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属 于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。

2.2 定义和使用格式

类变量

当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改 该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。

  • 类变量：使用 static关键字修饰的成员变量。 定义格式：
static 数据类型 变量名；

举例：

static int numberID；

比如说，基础班新班开班，学员报到。现在想为每一位新来报到的同学编学号（sid），从第一名同学开始，sid为 1，以此类推。学号必须是唯一的，连续的，并且与班级的人数相符，这样以便知道，要分配给下一名新同学的学 号是多少。这样我们就需要一个变量，与单独的每一个学生对象无关，而是与整个班级同学数量有关。

所以，我们可以这样定义一个静态变量numberOfStudent，代码如下：

public class Student { 
	private String name; 
	private int age; 
	// 学生的id 
	private int sid; 
	// 类变量，记录学生数量，分配学号 
	public static int numberOfStudent = 0; 
	
	public Student(String name, int age){ 
		this.name = name; 
		this.age = age; 
		
		// 通过 numberOfStudent 给学生分配学号 
		this.sid = ++numberOfStudent; 
	}
	// 打印属性值 
	public void show() { 
		System.out.println("Student : name=" + name + ", age=" + age + ", sid=" + sid ); 
	} 

}

public class StuDemo { 
	public static void main(String[] args) { 
		Student s1 = new Student("张三", 23); 
		Student s2 = new Student("李四", 24); 
		Student s3 = new Student("王五", 25); 
		Student s4 = new Student("赵六", 26); 
		
		s1.show(); // Student : name=张三, age=23, sid=1 
		s2.show(); // Student : name=李四, age=24, sid=2 
		s3.show(); // Student : name=王五, age=25, sid=3 
		s4.show(); // Student : name=赵六, age=26, sid=4 
	} 
}

静态方法

当 static 修饰成员方法时，该方法称为类方法 。静态方法在声明中有 static ，建议使用类名来调用，而不需要 创建类的对象。调用方式非常简单。

  • 类方法：使用 static关键字修饰的成员方法，习惯称为静态方法。 定义格式
 修饰符 static 返回值类型 方法名 (参数列表){ 
		 // 执行语句
 }

举例：在Student类中定义静态方法

public static void showNum() { 
	System.out.println("num:" + numberOfStudent); 
}
静态方法调用的注意事项：
  • 静态方法可以直接访问类变量和静态方法。
  • 静态方法不能直接访问普通成员变量或成员方法。反之，成员方法可以直接访问类变量或静态方法。
  • 静态方法中，不能使用this关键字。

小贴士：静态方法只能访问静态成员。

调用格式

被static修饰的成员可以并且建议通过类名直接访问。虽然也可以通过对象名访问静态成员，原因即多个对象均属 于一个类，共享使用同一个静态成员，但是不建议，会出现警告信息。

格式：

// 访问类变量 
类名.类变量名； 

// 调用静态方法 
类名.静态方法名(参数)；

调用演示，代码如下：

public class StuDemo2 { 
	public static void main(String[] args) { 
		// 访问类变量 
		System.out.println(Student.numberOfStudent); 
		// 调用静态方法 
		Student.showNum(); 
		} 
}

2.3 静态原理图解

static 修饰的内容：

  • 是随着类的加载而加载的，且只加载一次。
  • 存储于一块固定的内存区域（静态区），所以，可以直接被类名调用。
  • 它优先于对象存在，所以，可以被所有对象共享

在这里插入图片描述

2.4 静态代码块

  • 静态代码块：定义在成员位置，使用static修饰的代码块{ }。
    • 位置：类中方法外。
    • 执行：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

格式

public class ClassName{ 
	static { 
		// 执行语句 
		} 
}

作用：给类变量进行初始化赋值。用法演示，代码如下

public class Game { 
	public static int number; 
	public static ArrayList<String> list; 
	static { 
		// 给类变量赋值 
		number = 2; 
		list = new ArrayList<String>(); 
		// 添加元素到集合中 
		list.add("张三"); 
		list.add("李四"); } 
}

小贴士：
static 关键字，可以修饰变量、方法和代码块。在使用的过程中，其主要目的还是想在不创建对象的情况 下，去调用方法。下面将介绍两个工具类，来体现static 方法的便利。

第三章 Arrays类

3.1 概述

java.util.Arrays 此类包含用来操作数组的各种方法，比如排序和搜索等。其所有方法均为静态方法，调用起来 非常简单。

3.2 操作数组的方法

  • public static String toString(int[] a) ：返回指定数组内容的字符串表示形式。
public static void main(String[] args) { 
	// 定义int 数组 
	int[] arr = {2,34,35,4,657,8,69,9}; 
	// 打印数组,输出地址值 
	System.out.println(arr);// [I@2ac1fdc4 
	
	// 数组内容转为字符串 
	String s = Arrays.toString(arr); 
	// 打印字符串,输出内容 
	System.out.println(s); // [2, 34, 35, 4, 657, 8, 69, 9] 
}
  • public static void sort(int[] a) ：对指定的 int 型数组按数字升序进行排序。
	public static void main(String[] args) { 
	// 定义int 数组 
	int[] arr = {24, 7, 5, 48, 4, 46, 35, 11, 6, 2}; 
	System.out.println("排序前:"+ Arrays.toString(arr)); // 排序前:[24, 7, 5, 48, 4, 46, 35, 11, 6, 2]

	// 升序排序 
	Arrays.sort(arr); 
	System.out.println("排序后:"+ Arrays.toString(arr));// 排序后:[2, 4, 5, 6, 7, 11, 24, 35, 46, 48] }

3.3 练习

请使用 Arrays 相关的API，将一个随机字符串中的所有字符升序排列，并倒序打印。

public class ArraysTest { 
	public static void main(String[] args) { 
	// 定义随机的字符串 
	String line = "ysKUreaytWTRHsgFdSAoidq"; 

	// 转换为字符数组 
	char[] chars = line.toCharArray(); 
	
	// 升序排序 
	Arrays.sort(chars); 
	
	// 反向遍历打印 
	for (int i = chars.length‐1; i >= 0 ; i‐‐) { 
		System.out.print(chars[i]+" "); // y y t s s r q o i g e d d a W U T S R K H F A 
		} 
	} 
}

第四章 Math类

4.1 概述

java.lang.Math 类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。类似这样的工具 类，其所有方法均为静态方法，并且不会创建对象，调用起来非常简单。

4.2 基本运算的方法

绝对值

public static double abs(double a) ：返回 double 值的绝对值。

double d1 = Math.abs(‐5); //d1的值为5 
double d2 = Math.abs(5); //d2的值为5

大于等于参数的最小的整数

public static double ceil(double a) ：返回大于等于参数的最小的整数。

double d1 = Math.ceil(3.3); //d1的值为 4.0 
double d2 = Math.ceil(‐3.3); //d2的值为 ‐3.0 
double d3 = Math.ceil(5.1); //d3的值为 6.0

小于等于参数最大的整数。

public static double floor(double a)

double d1 = Math.floor(3.3); //d1的值为3.0 
double d2 = Math.floor(‐3.3); //d2的值为‐4.0 
double d3 = Math.floor(5.1); //d3的值为 5.0

最接近参数的 long

public static long round(double a) ：返回最接近参数的 long。(相当于四舍五入方法)

long d1 = Math.round(5.5); //d1的值为6.0 
long d2 = Math.round(5.4); //d2的值为5.0

4.3 练习

请使用 Math 相关的API，计算在 -10.8 到 5.9 之间，绝对值大于 6 或者小于 2.1 的整数有多少个？

public class MathTest { 
	public static void main(String[] args) { 
		// 定义最小值 
		double min = ‐10.8; 
		// 定义最大值 
		double max = 5.9; 
		// 定义变量计数 
		int count = 0; 
		// 范围内循环 
		for (double i = 		
			Math.ceil(min); i <= max; i++) { 
		// 获取绝对值并判断 
		if (Math.abs(i) > 6 || Math.abs(i) < 2.1) { 
				// 计数 
				count++; 
				} 
			}
		System.out.println("个数为: " + count + " 个"); 
	} 
}
简单@De@小新
关注
专栏目录
8.Java语言API，String类、static、Arrays类、Math类
让我去流浪啊
09-03 172
String类 1.    String类代表字符串，java中所有的字符串都被看成String类的实例（对象） 2.    特点： a)    一个字符串的值在创建后不能被改变 例如：String s1 = “abc”; s1 = “123”; 实际上，”abc”和“123”是两个字符串，s1 = “123”执行后,s1指向“123”这个字符串的地址，而不是把“123”这个值赋给s1 ...
javaSE基础笔记_Day08_String类,static关键字,Arrays类,Math类
weixin_45725615的博客
10-18 712
目录一、String类1、String类的概述和特点（1）概述（2）特点2、String类的构造方法（1）查看类:（2）查看构造方法:（3）创建String类的对象:3、能够明确String类的构造方法创建对象,和直接赋值创建字符串对象的区别4、String类的常用方法（1）判断功能的方法（2）获取功能的方法（3）转换功能的方法（4）分割功能的方法5、String类的练习（1）拼接字符串（2）统计...
Java基础【String类、static关键字、Arrays类、Math类】
hu_zhi_chao的博客
03-20 704
day08【String类、static关键字、Arrays类、Math类】第一章 String类1.1 String类概述概述特点1.2 使用步骤1.3 常用方法判断功能的方法获取功能的方法转换功能的方法分割功能的方法1.4 String类的练习拼接字符串统计字符个数第二章 static关键字2.1 概述2.2 定义和使用格式类变量静态方法调用格式2.3 静态原理图解2.4 静态代码块第三章 A...
Java基础—String类、static关键字、Arrays类、Math类
weixin_42214237的博客
10-24 208
一、java.lang.String 1.字符串 String类代表字符串，程序当中所有的双引号字符串，都是String类的对象。 2.字符串的特点 1.字符串的内容永不可变，字符串是常量。【重点】 2.因为字符串不可改变，所以字符串是可以【共享使用】的。（共享使用可以节省内存） 3.字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组。 3.创建字符串的方式 ...
Java的String类、static关键字、Arrays类、Math类
最新发布
m0_55597999的博客
04-03 774
Java的String类、static关键字、Arrays类、Math类
Java String类、static关键字、Arrays类、 Math类
Bikang001的博客
11-22 159
面向对象之String类、static关键字、Arrays类、 Math类 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 系列文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 前面总结的一些API方法都是面向对象的，今天继续来吧一些API方法总结出来 一、String类是什么？ 1、String类概述 概述 java.lang.String 类代表字符串。Java程序中所有的字符...
Java基础：String类、static关键字、Arrays类、Math类
时代各有不同，青春一脉相承。
12-02 616
java.lang.String类代表字符串。Java程序中所有的字符串文字（例如"abc"）都可以被看作是实现此类的实例。关于static关键字的使用，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用了。java.util.Arrays此类包含用来操作数组的各种方法，比如排序和搜索等。java.lang.Math类包含用于执行基本数学运算的方法，如初等指数、对数、平方根和三角函数。
String 类，static 关键字Arrays类，Math类
weixin_37689012的博客
08-18 154
String 类，static 关键字Arrays类，Math类 1.String 类的概述 java.lang.String 代表字符串，java程序中所有的字符串文字，都可以看成是实现此类的实例 类String 中包含用于检查字符串的各个方法，比如比较字符串，搜索字符串，截取字符串以及创建具有翻译为大写或者小写的所有字符的字符串文本。 特点：字符串不变：字符串的值在创建后不可修改 常用方法： equals :将此字符串与指定对象进行比较 equalsIgnoreCase :将此字符串与指定对象进行比较
JavaStudy08 String类、static关键字、Arrays类、 Math类
MF507的博客
03-25 176
20200322 目录：String类、static关键字、Arrays类、 Math类今日内容教学目标第一章 String类1.1 String类概述概述特点1.2 使用步骤查看类查看构造方法1.3 常用方法判断功能的方法获取功能的方法转换功能的方法分割功能的方法1.4 String类的练习拼接字符串统计字符个数第二章 static关键字2.1 概述2.2 定义和使用格式类变量静态方法调用格...
String类、 static关键字、 Arrays类、Math类
m0_48960643的博客
07-05 77
String类、 static关键字、 Arrays类、Math类
08【String类、static、Arrays类、Math类】1
08-04
Java中的`String`类是用于表示文本数据的类，它位于`java.lang`包下，是所有Java程序的基础。`String`对象是不可变的，这意味着一旦创建了一个`String`对象，就不能改变它的内容。这是因为字符串在Java中被视为常量...
Java入门到精通——第十二单元 static关键字，Arrays类，Math类
weixin_50009850的博客
03-22 475
第十二单元 static关键字，Arrays类，Math类本单元教学目标（Ⅰ）重点知识目标（Ⅱ）能力目标12.1 static关键字的概述12.1.1 static关键字的概述★★★★12.1.2 定义和使用格式★★★★12.1.3 静态原理图解★★★★12.1.4 静态代码块★★★12.2 Arrays类12.2.1 Arrays类的概述★★12.2.2 操作数组方法的使用★★★★★12.2.3 使用Arrays对字符串中的字符排序★★★12.3 Math类12.3.1 Math类的概述★★★12.3.2
XX教育 - oo - day01
weixin_44354035的博客
08-31 862
XX教育回顾:正课:1.什么是类？什么是对象？2.如何创建类？如何创建对象？如何访问成员？3.引用类型之间画等号:4.null:空，没有指向任何对象练习: 回顾: 1.方法: 封装特定的逻辑功能、独立、只干一件事 被调用多次，减少重复，有利于复用，有利于团队协作 2.方法的定义: 修饰词 返回值类型 方法名(参数列表){ 方法体 } 3.方法的调用: 1)无返回值: 方法名(有参传参); 2)有返回值: 数据类型 变量 = 方法名(有参传参); 方法名(有参传参);----------不建议 4.retur
Java 第11天 final、权限、内部类、引用类型学习
weixin_44354035的博客
08-11 804
final、权限、内部类、引用类型第一章 final关键字1.1 概述1.2 使用方式修饰类修饰方法1. 局部变量——基本类型2. 局部变量——引用类型3. 成员变量第二章 权限修饰符2.1 概述2.2 不同权限的访问能力第三章 内部类1.1 概述什么是内部类成员内部类访问特点1.2 匿名内部类【重点】前提格式使用方式第四章 引用类型用法总结4.1 class作为成员变量4.2 interface作为成员变量4.3 interface作为方法参数和返回值类型第五章 综合案例——发红包【界面版】案例需求案例分
Java 第 10 天 关于接口、多态问题
weixin_44354035的博客
08-05 689
第一章 接口 1.1 概述 接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么 接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法 （JDK 9）。 接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并 不是类，而是另外一种引用数据类型。 引用数据类型：数组，类，接口。 接口的使用，它不能创建对象，但是可以被实现（ implement
Java 第19天 File类、递归
weixin_44354035的博客
08-12 555
File类、递归day08【File类、递归】主要内容教学目标第一章 File类1.1 概述1.2 构造方法1.3 常用方法获取功能的方法绝对路径和相对路径判断功能的方法创建删除功能的方法1.4 目录的遍历第二章 递归2.1 概述2.2 递归累加求和计算1 ~ n的和代码执行图解2.3 递归求阶乘2.4 递归打印多级目录第三章 综合案例3.1 文件搜索3.2 文件过滤器优化3.3 Lambda优化 day08【File类、递归】 主要内容 File类 递归 教学目标 能够说出File对象的创建方式
Java 第5天 数组
weixin_44354035的博客
08-11 487
数组第一章 数组定义和访问1.1 容器概述1.2 数组概念1.3 数组的定义方式一方式二方式三1.4 数组的访问第二章 数组原理内存图2.1 内存概述2.2 Java虚拟机的内存划分2.3 数组在内存中的存储一个数组内存图两个数组内存图两个变量指向一个数组第三章 数组的常见操作3.1 数组越界异常3.2 数组空指针异常3.5 数组反转第四章 数组作为方法参数和返回值4.1 数组作为方法参数4.2 数组作为方法返回值4.3 方法的参数类型区别 第一章 数组定义和访问 1.1 容器概述 案例分析 现在需要统计某
Java 第1天 前言部分、入门程序、常量、变量学习
weixin_44354035的博客
07-23 477
前言部分、入门程序、常量、变量学习第一章 开发前言1.1 Java语言概述1、什么是Java语言2、Java语言发展历史3、Java语言能做什么1.2 计算机基础知识1、二进制2、字节3、常用DOS命令第二章 Java语言开发环境搭建2.1 Java虚拟机——JVM2.2 JRE 和 JDK2.3 JDK9安装图解2.4 JAVA_HOME环境变量的配置配置环境变量步骤第三章 HelloWorld入门程序3.1 程序开发步骤说明3.2 编写Java源程序3.3 编译Java源文件3.4 运行Java程序3.
掌握Java编程：static关键字，Arrays与Math类详解
本资源主要介绍了Java编程中的第十二单元，包括`static`关键字、`Arrays`类和`Math`类的相关知识。这部分内容主要针对《java从入门到精通》第九章的数字处理类，讲解范围集中在第138至163页。教学时长为4课时，共计...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

简单@De@小新

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值