JavaSEDemo09

谁践踏了优雅 2021-09-25 06:22 238阅读 0赞

### 文章目录 ###

*  简介
 *  练习题目:统计字符串中不同字符的个数
 *   *  代码示例
     *  程序运行结果
 *  final关键字
 *   *  final关键字修饰变量
     *  常量声明时关于初始化的要求
     *  final修饰方法
     *  final修饰类
 *  static关键字
 *   *  静态变量及其特点
     *  静态方法及其特点
     *  静态方法与非静态方法的互相调用
     *  静态导入
 *  包装类
 *   *  装箱和拆箱
 *  包装类
 *  装箱和拆箱
 *   *  byte范围内自动装箱的情况
     *  byte范围外自动装箱的情况
 *  内部类
 *   *  成员内部类
     *   *  创建成员内部类对象
     *  局部内部类
     *  静态内部类
     *  匿名内部类

# 简介 #

*  本文是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]+" ");
            }
        }
    }

## 程序运行结果 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h5cGVydGV4dDEyMw_size_16_color_FFFFFF_t_70_pic_center]

# final关键字 #

## final关键字修饰变量 ##

*  final关键字修饰的变量是常量，不可以改变。
 *  语法:权限修饰符 final 数据类型 变量名称(需全部大写,单词间用下划线分开) = 值;
 *  例如: public final int STUDENT\_NAME = “张三”;

## 常量声明时关于初始化的要求 ##

1.  直接在声明常量时初始化赋值。  
    例如:public final int NAME = “张三”
2.  可以先声明常量，然后在初始化代码块中赋值

*  代码示例

public class User{ 
    public final int AGE;
    //初始化代码块(只有一个大括号)
    { 
    AGE = 20;
    }
    }

1.  可以先声明静态常量，然后在静态代码块中赋值(不可在静态代码块中初始化非静态常量)

*  代码示例

public class Animal { 
    //静态常量AGE
        public static final int AGE;
        //静态代码块
        static { 
            AGE = 20;
        }
    }

1.  构造方法中也可以对常量进行初始化赋值(静态常量不可)

*  代码示例

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关键字(原因:静态方法不属于任何对象)

## 静态方法与非静态方法的互相调用 ##

1.  静态方法中不能直接调用非静态方法，会报错  
    解决方案:在静态方法中创建一个本类对象，通过这个对象调用非静态方法
2.  非静态方法可以随意调用静态方法

## 静态导入 ##

*  语法: 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个包装类，分别是:

1.  byte - Byte
2.  short - Short
3.  int - Integer
4.  long - Long
5.  float - Float
6.  double - Double
7.  char - Character
8.  boolean - Boolean

## 装箱和拆箱 ##

*  # 包装类 #
    
     *  不是对象的类型 八大基本类型  
        int - Integer char -Character

# 装箱和拆箱 #

*  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种内部类:成员内部类 局部内部类 静态内部类 匿名内部类

## 成员内部类 ##

*  内部类作为外部类的成员
 *  内部类可以直接访问外部类的成员变量
 *  注意:成员内部类中不能存在静态方法和静态变量
 *  必须先创建外部类，才能创建成员内部类

### 创建成员内部类对象 ###

1.  先创建外部类对象
2.  外部类.内部类 内部类对象名称 = 外部类对象.new 内部类()；
3.  代码示例

//外部类
    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();
    }
    }

1.  程序运行结果

姓名:张三 年龄: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 = 张三

## 匿名内部类 ##

*  没有名字的内部类就是匿名内部类
 *  使用条件:匿名内部类必须继承一个父类或者实现一个接口
 *  创建匿名内部类的格式:
 *  \[ 访问权限 \] \[ 修饰符 \]父类名/接口名 引用名 = new 父类名/接口名（\[父类构造方法参  
    数列表\]）｛  
    匿名内部类成员；  
    ｝
 *  匿名内部类没有构造方法
 *  创建匿名内部类代码示例

public class OuterClass { 
      private String name = "张三";
      private int age = 20;
      A a = new A(){ 
        public void show(){ 
        System.out.println("name:"+name+" age:"+age);
        }
      }
    }
    interface A{ 
        int ma();
    }
    
    class Test{ 
       public static void main(String[] args) { 
            //创建外部类对象
            AnnoymousInnerClass annoymousInnerClass = new AnnoymousInnerClass();
            //通过外部类对象调用成员a,然后调用show方法
            annoymousInnerClass.a.show();
        }
    
    }

程序运行结果

name:张三 age: 20

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2h5cGVydGV4dDEyMw_size_16_color_FFFFFF_t_70_pic_center]: /images/20210923/fb81ae21170f4c369c70c2f563c42266.png