文章目录
简介
- 本文是2021/03/31整理的笔记
- 赘述可能有点多，还请各位朋友耐心阅读
- 本人的内容和答案不一定是最好最正确的，欢迎各位朋友评论区指正改进
练习题目:统计字符串中不同字符的个数
- 定义一个方法，含有字符串参数，分别统计字符串中字母，数字，特殊符号的个数，并打印
代码示例
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
//创建Scanner类对象
Scanner scanner = new Scanner(System.in);
System.out.println("请输入一个字符串");
String string = scanner.next();
//调用自定义的方法
method(string);
}
//定义静态方法，用于打印输出字符串中字母个数 数字个数 其它字符个数
public static void method(String string){
//定义字母个数 数字个数 其它字符个数
int countLetter = 0;
int countNumber = 0;
int countOther = 0;
//定义存储字母的数组 存储数字的数组 存储其他字符的数组
char [] letter = new char[string.length()];
char [] number = new char[string.length()];
char [] other = new char[string.length()];
//将字符串转换为字符数组
char[] chars = string.toCharArray();
//满足条件的则存储到相应的数组中，相应个数加1
for (int i = 0; i < chars.length; i++) {
if('A'<=chars[i] && chars[i]<='z'){
letter[countLetter] = chars[i];
countLetter++;
}else if('0'<chars[i] && chars[i]<'9'){
number[countNumber] = chars[i];
countNumber++;
}else {
other[countOther] = chars[i];
countOther++;
}
}
//遍历打印字母数组 数字数组 其他字符数组的每个元素
System.out.println("字母个数:"+countLetter);
for (int i = 0; i < letter.length; i++) {
System.out.print(letter[i]+" ");
}
System.out.println();
System.out.println("数字个数:"+countNumber);
for (int i = 0; i < number.length; i++) {
System.out.print(number[i]+" ");
}
System.out.println();
System.out.println("其他字符个数:"+countOther);
for (int i = 0; i < other.length; i++) {
System.out.print(other[i]+" ");
}
}
}
程序运行结果
final关键字
final关键字修饰变量
- final关键字修饰的变量是常量，不可以改变。
- 语法:权限修饰符 final 数据类型 变量名称(需全部大写,单词间用下划线分开) = 值;
- 例如: public final int STUDENT_NAME = “张三”;
常量声明时关于初始化的要求
- 直接在声明常量时初始化赋值。
例如:public final int NAME = “张三” - 可以先声明常量，然后在初始化代码块中赋值
- 代码示例
public class User{
public final int AGE;
//初始化代码块(只有一个大括号)
{
AGE = 20;
}
}
- 可以先声明静态常量，然后在静态代码块中赋值(不可在静态代码块中初始化非静态常量)
- 代码示例
public class Animal {
//静态常量AGE
public static final int AGE;
//静态代码块
static {
AGE = 20;
}
}
- 构造方法中也可以对常量进行初始化赋值(静态常量不可)
- 代码示例
public class Animal {
//非静态常量可以在构造方法中初始化赋值
public final int AGE;
public Animal() {
AGE = 20;
}
}
final修饰方法
- 语法:权限修饰符 final 返回值类型 方法名称(参数列表){ }
- 不能和abstract一起使用
final关键字意味着子类不能覆盖重写，abstract意味着父类的抽象方法，必须要由子类重写实现。二者矛盾。 - 无法被子类重写
final修饰类
- 语法:权限修饰符 final class 类名{ }
- 无法被子类继承
- 最常见的final类 String类
static关键字
静态变量及其特点
- 语法:权限修饰符 static 变量名 = 值;
- 特点:所有对象共享一个静态成员变量。
- 类和对象都可以调用静态成员变量(推荐使用类调用)
代码示例
public class Animal {
public static int age;
}
public class Test {
public static void main(String[] args) {
Animal animal1 = new Animal();
Animal animal2 = new Animal();
//修改animal1的年龄为3
animal1.age = 3;
System.out.println(animal1.age);
System.out.println(animal2.age);
}
}
程序运行结果
3
3
静态方法及其特点
- 语法:权限修饰符 static 返回值类型 方法名称(参数列表){ }
- 对象和类都可以调用静态成员方法(推荐使用类)
- 静态方法只能操作方法内声明的局部变量或静态成员变量
- 静态方法不能操作非静态成员变量
- 静态方法中不能使用this关键字(原因:静态方法不属于任何对象)
静态方法与非静态方法的互相调用
- 静态方法中不能直接调用非静态方法，会报错
解决方案:在静态方法中创建一个本类对象，通过这个对象调用非静态方法 - 非静态方法可以随意调用静态方法
静态导入
- 语法: import static 包名.类名.静态方法(或静态变量)
- 也可以直接import static 包名.* 直接导入所有的静态方法和静态变量，这样做可读性很差
代码示例
import static java.lang.Math.PI;
public class Test{
public static void main(String[] args){
//可以直接写PI
System.out.println(PI);
}
}
程序运行结果
3.141592653589793
包装类
八大基本类型对应8个包装类，分别是:
- byte - Byte
- short - Short
- int - Integer
- long - Long
- float - Float
- double - Double
- char - Character
- boolean - Boolean
装箱和拆箱
装箱和拆箱
- JDK1.5以后，可以实现自动装箱和自动拆箱
- 自动装箱和自动拆箱使用的是常量池的数据
- byte范围内(-128 ~ 127)会存储在常量池 超出范围就会new
byte范围内自动装箱的情况
- 说明:byte范围内自动装箱，使用的是常量池中的数据，地址是一样的
public class Test{
public static void main(String[] args){
//自动装箱
Integer a1 = 10;
Integer a2 = 10;
//手动装箱
Integer a3 = new Integer(10);
Integer a4 = new Integer(10);
//比较a1和a2 a3和a4的地址值
System.out.println(a1 == a2);
System.out.println(a3 == a4);
}
}
程序运行结果
true
false
byte范围外自动装箱的情况
- 说明:byte范围外自动装箱，编译器只能new创建新的对象，所以地址不同。
public class Test{
public static void main(String[] args){
//自动装箱
Integer a1 = 1000;
Integer a2 = 1000;
//手动装箱
Integer a3 = new Integer(1000);
Integer a4 = new Integer(1000);
//比较a1和a2 a3和a4的地址值
System.out.println(a1 == a2);
System.out.println(a3 == a4);
}
}
程序运行结果
false
false
内部类
- 一共有4种内部类:成员内部类 局部内部类 静态内部类 匿名内部类
成员内部类
- 内部类作为外部类的成员
- 内部类可以直接访问外部类的成员变量
- 注意:成员内部类中不能存在静态方法和静态变量
- 必须先创建外部类，才能创建成员内部类
创建成员内部类对象
- 先创建外部类对象
- 外部类.内部类 内部类对象名称 = 外部类对象.new 内部类()；
- 代码示例
//外部类
public class OuterClass{
//外部类的成员变量
private String name;
private int age;
//内部类
public class InnerClass{
//内部类构造方法
public InnerClass(){
name = "张三";
age = 20;
}
//内部类普通方法show
public void show(){
System.out.println("姓名:"+name+" 年龄:"+age);
}
}
}
//测试类
public class Test{
public static void main(String[] args){
//1.先创建外部类对象
OuterClass outer = new OuterClass();
//2.外部类.内部类声明引用
//3.通过外部类对象.new方法 创建内部类对象
OuterClass.InnerClass inner = outer.new InnerClass();
//4.内部类对象调用内部类普通方法
inner.show();
}
}
- 程序运行结果
姓名:张三 年龄:20
局部内部类
- 局部内部类是定义在方法中的类
- 局部内部类只能在该方法和作用域中被使用
- 局部内部类可以直接操作外部类的成员变量，但是对于方法的临时变量（包括方法的
参数，要求是final常量才能操作） - 对于方法参数，无论加不加final关键字，都不能修改数值
静态内部类
- 静态内部类与非静态内部类之间存在一个最大的区别，非静态内部类在编译完成之后
会隐含地保存着一个引用，该引用是指向创建它的外部类，但是静态内部类却没有。
没有这个引用就意味着：
(1)它的创建是不需要依赖于外部类的
(2)它不能使用任何外部类的非static成员变量和方法
(3)和成员内部类不同，static内部类能够声明static的成员 - 创建静态内部类对象代码示例
public class OuterClass {
private String sex;
private static String name = "张三";
//静态内部类
static class InnerClass{
public static String staticName = "李四";
public void show(){
System.out.println("Outerclass.name = " + name);
}
}
public void show(){
System.out.println(InnerClass.staticName);
//创建内部类对象，调用它的方法
new InnerClass().show();
}
}
public class OuterClassTest {
public static void main(String[] args) {
//创建外部类对象
OuterClass outerClass = new OuterClass();
outerClass.show();
}
}
- 程序运行结果
李四
Outerclass.name = 张三