Java第24天~25天/12.23~12.24
day24
Java设计模式
一、静态工厂模式（简单工厂模式）
静态工厂方法模式里面需要提供一个类:工厂类(用它制造一些需要的对象)
* 特点:
* 构造方法私有化,外界不能直接创建它的对象
* 提供静态功能,每一种静态都会产生所需要的对象…
* 缺点:不利于后期维护
* 如果添加新的对象,需要创建它的类还需要在静态工厂类提供一些功能!
package org.westos_01_简单工厂模式;
/**
* 静态工厂方法模式里面需要提供一个类:工厂类(用它制造一些需要的对象)
* 特点:
* 构造方法私有化,外界不能直接创建它的对象
* 提供静态功能,每一种静态都会产生所需要的对象...
* 缺点:不利于后期维护
* 如果添加新的对象,需要创建它的类还需要在静态工厂类提供一些功能!
* @author 小鑫
*
*/
public class AnimalDemo {
public static void main(String[] args) {
//提供静态工厂
Animal a = AnimalFactory.createAnimal("dog");
a.eat();
a = AnimalFactory.createAnimal("cat");
a.eat();
a = AnimalFactory.createAnimal("pig");
if(a!=null){
a.eat();
}else{
System.out.println("工厂类没有提供该动物");
}
/*
* 狗吃肉
* 猫吃鱼
* 工厂类没有提供该动物
*/
}
}
package org.westos_01_简单工厂模式;
public abstract class Animal {
public abstract void eat();
}
class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗吃肉");
}
}
class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
package org.westos_01_简单工厂模式;
/**
* 动物工厂类
* @author 小鑫
*
*/
public class AnimalFactory {
//私有功能
private AnimalFactory(){
}
public static Animal createAnimal(String type){
if("dog".equals(type)){
return new Dog();
}else if("cat".equals(type)){
return new Cat();
}else{
return null;
}
}
}
二、工厂方法模式
工厂方法模式:
* 特点:
* 需要提供一个抽象类,以及每个动物的具体类和接口(工厂接口)
* 该接口中的抽象方法的返回值是该抽象类
* 针对每个具体动物都提供一些对应的工厂类—>实现该接口—>返回值就是需要具体的动物对象
package org.westos_02_工厂方法模式;
/**
* 工厂方法模式:
* 特点:
* 需要提供一个抽象类,以及每个动物的具体类和接口(工厂接口)
* 该接口中的抽象方法的返回值是该抽象类
* 针对每个具体动物都提供一些对应的工厂类--->实现该接口--->返回值就是需要具体的动物对象
*
* 弊端:代码量大了.
* @author 小鑫
*
*/
public class AnimalDemo {
public static void main(String[] args) {
//需求： 养一只狗
DogFactory df = new DogFactory();
Animal a = df.cereatAnimal();
a.eat();
//养一只猫
CatFactory cf = new CatFactory();
a = cf.cereatAnimal();
a.eat();
//狗吃肉
//猫吃鱼
}
}
package org.westos_02_工厂方法模式;
public abstract class Animal {
public abstract void eat();
}
class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
class Dog extends Animal{
@Override
public void eat() {
System.out.println("狗吃肉");
}
}package org.westos_02_工厂方法模式;
//工厂接口
public interface Factory {
//提供常见动物功能
public abstract Animal cereatAnimal();
}
//猫工厂类提供对象
class CatFactory implements Factory{
@Override
public Animal cereatAnimal() {
return new Cat();
}
}
//狗工厂提供对象
class DogFactory implements Factory{
@Override
public Animal cereatAnimal() {
return new Dog();
}
}三、单例模式
单例模式:在内存中始终只有一个对象
- 饿汉式
- 特点:当前某一个一加载,就会创建一个对象
- 需要将该类的无参构造私有化
- 在成员变量创建该类的实例
- 需要提供公共的访问方法
- 懒汉式
- 特点:并不是加载某个类就直接创建对象,而是需要的时候在创建对象
- 1)懒加载(延迟加载)
- 2)线程的安全问题
- 检验标准:
- a:是否是多线程环境
- b:是否有共享数据1
- c:是否有多条语句对共享数据进行操作!
- 使用同步代码块进行解决
1、饿汉式
package org.westos_03_单例模式;
/**
* 饿汉式
* 特点:当前某一个一加载,就会创建一个对象
* 需要将该类的无参构造私有化
* 在成员变量创建该类的实例
* 需要提供公共的访问方法
* @author 小鑫
*
*/
public class StudentDemo {
public static void main(String[] args) {
//利用静态公共访问方法创建对象
Student s1 = Student.getStudent();
Student s2 = Student.getStudent();
System.out.println(s1==s2);//true
System.out.println(s1);//org.westos_03_单例模式.Student@3654919e
System.out.println(s2);//org.westos_03_单例模式.Student@3654919e
}
}
package org.westos_03_单例模式;
public class Student {
//无参构造私有化，不让外界创建对象
private Student(){
}
//在成员变量位置创建该类实例
//静态只能访问静态，static修饰
private static Student s=new Student();
//提供公共访问方法，返回该类实例对象
public static Student getStudent(){
return s;
}
}
2、懒汉式
package org.westos_03_单例模式;
/**
* 懒汉式
* 特点:并不是加载某个类就直接创建对象,而是需要的时候在创建对象
* 1)懒加载(延迟加载)
* 2)线程的安全问题
* 检验标准:
* a:是否是多线程环境
* b:是否有共享数据1
* c:是否有多条语句对共享数据进行操作!
* 使用同步代码块进行解决
* @author 小鑫
*/
public class TeacherDemo {
public static void main(String[] args) {
Teacher t1 = Teacher.getTeacher();
Teacher t2 = Teacher.getTeacher();
System.out.println(t1==t2);//true
System.out.println(t1);//org.westos_03_单例模式.Teacher@6084fa6a
System.out.println(t2);//org.westos_03_单例模式.Teacher@6084fa6a
}
}
package org.westos_03_单例模式;
public class Teacher {
// 构造方法私有化
private Teacher() {
}
// 成员位置声明变量
private static Teacher t = null;//共享数据
//提供公共放访问方法
public synchronized static Teacher getTeacher(){
//判断 当当前该对象没有更多引用的时候,才创建对象
if(t==null){
t = new Teacher();
}
return t;
}
}
四、装饰者模式
package org.westos_04_装饰者模式;
public class PhoneDemo {
public static void main(String[] args) {
// 打电话
Phone p = new IPhone();
p.call();// 手机可以打电话了...
System.out.println("-----------");
// 打电话前听彩铃
PhoneDecorate pd = new RingPhoneDecorate(p);
pd.call();
// 手机可以听彩铃...
// 手机可以打电话了...
System.out.println("------------");
// 打完电话，听音乐
pd = new MusicPhoneDecorate(p);
pd.call();
// 手机可以打电话了...
// 手机可以听音乐了...
System.out.println("-----------");
// 改进：先听彩铃，然后打电话，最后听音乐
pd = new RingPhoneDecorate(new MusicPhoneDecorate(p));
pd.call();
/*手机可以听彩铃...
手机可以打电话了...
手机可以听音乐了...*/
}
}
package org.westos_04_装饰者模式;
//打电话接口
public interface Phone {
public abstract void call();
}
//具体手机类
class IPhone implements Phone{
@Override
public void call() {
System.out.println("手机可以打电话了...");
}
}package org.westos_04_装饰者模式;
public class MusicPhoneDecorate extends PhoneDecorate {
public MusicPhoneDecorate(Phone p) {
super(p);
}
@Override
public void call() {
super.call();
System.out.println("手机可以听音乐了...");
}
}
package org.westos_04_装饰者模式;
public class PhoneDecorate implements Phone{
private Phone p;
public PhoneDecorate(Phone p){
this.p=p;
}
@Override
public void call() {
this.p.call();
}
}
package org.westos_04_装饰者模式;
public class RingPhoneDecorate extends PhoneDecorate {
public RingPhoneDecorate(Phone p) {
super(p);
}
@Override
public void call() {
System.out.println("手机可以听彩铃...");
super.call();
}
}
五、枚举
package org.westos_05_枚举;
//测试类
public class DirectionDemo {
public static void main(String[] args) {
Direction1 front = Direction1.FRONT;
System.out.println(front);
//org.westos_05_枚举.Direction1@6a2437ef
System.out.println("--------------");
Direction2 behind = Direction2.BEHIND;
System.out.println(behind);
//org.westos_05_枚举.Direction2@3cf5b814
String name = behind.getName();
System.out.println(name);//后
System.out.println("--------------");
Direction3 left = Direction3.LEFT;
System.out.println(left.getName());//左
left.show();//左
}
}
package org.westos_05_枚举;
public class Direction1 {
// 创建实例对象
public static final Direction1 FRONT = new Direction1();
public static final Direction1 BEHIND = new Direction1();
public static final Direction1 LEFT = new Direction1();
public static final Direction1 RIGHT = new Direction1();
//提供公共构造方法
public Direction1(){
}
}
package org.westos_05_枚举;
public class Direction2 {
// 创建几个实例对象
public static final Direction2 FRONT = new Direction2("前");
public static final Direction2 BEHIND = new Direction2("后");
public static final Direction2 LEFT = new Direction2("左");
public static final Direction2 RIGHT = new Direction2("右");
//私有化无参构造
private Direction2(){
}
private String name;
public Direction2(String name){
this.name=name;
}
public String getName(){
return name;
}
}
package org.westos_05_枚举;
public abstract class Direction3 {
//提供子实现类
public static final Direction3 FRONT=new Direction3("前"){
@Override
public void show() {
System.out.println("前");
}
};
public static final Direction3 BEHIND=new Direction3("后"){
@Override
public void show() {
System.out.println("后");
}
};
public static final Direction3 LEFT=new Direction3("左"){
@Override
public void show() {
System.out.println("左");
}
};
public static final Direction3 RIGHT=new Direction3("右"){
@Override
public void show() {
System.out.println("右");
}
};
private Direction3(){
}
private String name ;
public Direction3(String name) {
this.name = name ;
}
public String getName(){
return name ;
}
//抽象方法
public abstract void show();
}
六、枚举
package org.westos_06_枚举;
public class DirectionDemo {
public static void main(String[] args) {
Direction1 front = Direction1.FRONT;
System.out.println(front);//FRONT 枚举里面直接输出当前实例名称
System.out.println("-------------");
Direction2 behind = Direction2.BEHIND;
System.out.println(behind);
String name = behind.getName();//BEHIND
System.out.println(name);//后
System.out.println("-------------");
Direction3 left = Direction3.LEFT;
System.out.println(left);//LEFT
System.out.println(left.getName());//左
left.show();//左
}
}
package org.westos_06_枚举;
public enum Direction1 {
// 创建几个实例
FRONT, BEHIND, LEFT, RIGHT;
}
package org.westos_06_枚举;
public enum Direction2 {
FRONT("前"),BEHIND("后"),LEFT("左"),RIGHT("右");
private String name;
private Direction2(String name){
this.name=name;
}
public String getName(){
return name;
}
}
package org.westos_06_枚举;
public enum Direction3 {
FRONT("前"){
@Override
public void show() {
System.out.println("前");
}
}
,
BEHIND("后"){
@Override
public void show() {
System.out.println("后");
}
}
,
LEFT("左"){
@Override
public void show() {
System.out.println("左");
}
}
,
RIGHT("右"){
@Override
public void show() {
System.out.println("右");
}
}
;
private String name ;
private Direction3(String name){
this.name = name ;
}
public String getName(){
return name ;
}
public abstract void show();
}
JavaSE测试题
1.在JAVA中，下列哪些说法是正确的（AC）
A．java源文件的扩展名为.java
B．写好的java源程序可以直接运行
C．编写的源程序必须先编译后才能运行
D．程序员可以读懂扩展名为.class的文件
2.下列标识符哪个是合法的（BD）
A．class
B．$abc
C．1234
D．_name
3.下面哪些赋值语句是正确的?(A)
A. long test = 012;
B. int other = (int) true;
C. double d = 0x12345678;
D. byte b = 128;
4.在Java中，下列语句不能通过编译的有(BD)
A. String s= “join”+ 3;
B. int a= “join”+3;
C. int a= ‘a’+5;
D. float f=5+5.5;
5.下列代码运行的结果是( C)
public static void main(String[] args) {
int x = 4;
int y = 5;
if(x++>4 & ++y>5) { //X=5,Y=6
x++;
}
System.out.println("x=" + x + ",y=" + y);
}A. x=4,y=5
B. x=4,y=6
C. x=5,y=6
D. x=6,y=6
6.尝试运行下面的代码会发生什么？(B)
public class Test {
public static void main(String[] args) {
boolean m = true;
if (m = false) {
System.out.println("true");
} else {
System.out.println("false");
}
}
}A. 输出字符串”true”
B. 输出字符串”false”
C. 编译时错误
D. 运行时错误
7.编译并运行以下代码将发生什么？ （ E）
public static void main(String args[]){
char digit = 'a';
for (int i = 0; i < 10; i++){
switch (digit)
{
case 'x' :
{
int j = 0;
System.out.println(j);
}
default :
{
int j = 100;
System.out.println(j);
}
}
}
int i = j;
System.out.println(i);
}A. 输出11次100
B. 输出10次100，然后抛出运行期异常
C. 编译错误，因为变量i不能在main() 方法中被声明2次
D. 编译错误，因为变量j不能在main() 方法中被声明2次
E. 以上都不对
8.（B）
class Demo
{
public static int fun(int c)
{
return c+=2;
}
public static void main(String[] args)
{
int temp = fun(2);
System.out.println(temp);
}
}A. 2
B. 4
C. 6
D. 8
9.下面哪些函数是public void aMethod(){…}的重载函数?(BD)
A. void aMethod( ){…}
B. public int aMethod(int a, float b){…}
C. public void aMethod (){…}
D. public float aMethod (int m){…}
//返回值类型不能作为是否是重载方法的判断依据
10.在java中，关于数组描述正确的是（BD）
A．数组中的索引下标从1开始
B．存储在数组当中的数据都属于同一数据类型
C．通过数组名.length()能获得数组的长度
D．数组的最大索引下标是数组的长度减1
11.下面程序的输出结果是什么(D )
int[] arr = new int[10];
System.out.println(arr[0]);
A．编译不通过
B．运行时出错
C．输出null
D．输出0
12.下面哪个语句正确地声明一个整型的二维数组( C)
A. int a[][] = new int[][];
B. int b[10][10] = new int[][];
C. int c[][] = new int[10][10];
13.以下代码输出是（ D ）
class Demo {
public static void main(String[] args) {
int i = 0;
int sum = 0;
while (i <= 10) {
i++;
if (i % 2 != 0)
continue;
sum += i;
}
System.out.println(sum);
}
}A. 55
B. 45
C. 35
D. 30
14.和下面代码能完成相同的选项是（B）
class Demo {
public static void main(String[] args) {
int i = 1;
int sum = 0;
while (i <= 100) {
if (i % 2 == 0) {
sum = sum + i;
}
i++;
}
System.out.println(sum);
}
} A. for (int x =1; x<=100;x++){ sum=sum+x;}
B. for (int x =0; x<=100;x+=2){ sum=sum+x;}
C. for (int x =1; x<=100;x+=2){ sum=sum+x;}
D.上述全对
15.下列有关类、对象和实例的叙述，正确的是哪一项？(D)
A．类就是对象，对象就是类，实例是对象的另一个名称，三者没有差别
B．对象是类的抽象，类是对象的具体化，实例是对象的另一个名称
C．类是对象的抽象，对象是类的具体化，实例是类的另一个名称
D．类是对象的抽象，对象是类的具体化，实例是对象的另一个名称
16.下面关于java中包的说法正确的是(ACD)
A. 在java中可以使用import语句导入包
B. 在java中可以使用package语句导入包
C. 位于同一个包中的类，不需要导包就可以直接访问
D. 不同的包中可以出现类名相同的类
17.下列有关抽象类的叙述正确的是哪项？(C)
A．抽象类中一定含有抽象方法
B．抽象类既能被实例化也能被继承
C．抽象类的声明必须包含abstract关键字
D．抽象类中不能有构造方法
18.下列有关接口的叙述错误的是哪项？(CD)
A．接口中只能包含抽象方法和常量
B．一个类可以实现多个接口
C．类实现接口时必须实现其中的方法
D．接口不能被继承
19.下列关于类的继承的描述，正确的有（ BD ）
A. 一个类可以同时继承多个父类
B. 一个类可以具有多个子类
C. 子类会自动拥有父类所有的方法
D. 一个类继承另一个类需要使用 extends 关键字
20.下列选项中关于java中this关键字的说法错误的有( C )
A. this关键字是一个对象的引用
B. this可用于构造函数中，调用类本身重载的构造函数，但是必须写在首行
C. this可用于静态方法中
21.下列关于构造函数的说法正确的是( AB )
A. 方法名必须与类名相同
B. 使用new关键字创建对象时，java虚拟机会自动调用构造函数
C. 我们在定义一个类时，必须要声明至少一个构造函数
D. 构造函数中不能使用return语句(这个是错的，可以rutrun;)
22.编译并运行以下代码将发生什么？( D )
class MyClass {
int x;
MyClass(int i) {
x = i;
}
public static void main(String args[]) {
MyClass m1 = new MyClass(100);
MyClass m2 = new MyClass(100);
if (m1.equals(m2)) {
System.out.println("Both are equal");
} else {
System.out.println("Both are not equal");
}
}
}A. 代码编译时报出错误提示信息“equals() 方法未定义”
B. 编译通过，抛出运行期异常.
C. 输出Both are equal.
D. 输出Both are not equal
23.运行以下的main()方法，结果是？（ A ）
1 public static void main(String[] args)
2 {
3 String myString;
4 int x = 100;
5
6 if (x < 100) myString = "x is less than 100";
7 if (x > 100) myString = "x is greater than 100";
8 System.out.println(myString.length());
9 }A． 编译时报出错误提示信息“变量myString没有被初始化”
B． 编译通过
C． 编译未能通过。但如果变量myString在第8行前的代码中被初始化，代码可以编译通过，运行时可以输出字符串myString的长度
D． 以上都不对
24.关于继承, 以下说法正确的是: (A)
A．Java中只支持单继承, 一个类只能继承一个类, 但是可以有多个子类
B．一个类如果没有自己写无参构造方法, 那么子类将无法继承
C．子类可以当父类用, 父类不可以当子类用
D. 子类重写父类方法时访问权限不能更低
25.在Java中，如果要在字符串类型对象s=”java”中，得到字符 ‘v’ 出现的位置，可使用下面的那个方法?（ C ）
A. s.matches(‘v’);
B. s.charAt(‘v’);
C. s.indexOf(‘v’);
D. s.substring(‘v’);
26.下列关于ArrayList和LinkedList集合的说法正确是有( ABC )
A. ArrayList集合底层是数组实现，该集合线程不安全
B. LinkedList集合底层是链表结构，适合做元素的增删操作
C. 这三个集合都是List接口的实现类
27.下面程序的输出结果是什么( D )
Set set= new HashSet();
set.add(“aaa”);
set.add(“bbb”);
set.add(“aaa”);
System.out.println(set.size());
A. 编译不通过
B. 运行时出错
C. 输出3
D. 输出2
28.下列哪些方法是ArrayList和LinkedList集合中都定义的( ACD )
A. add(Object o)
B. removeFirst()
C. remove(Object o)
D. add(int index,Object o)
29.下列哪些集合属于Collection体系的子类( BD )
A. TreeMap
B. ArrayList
C. Hashtable
D. HashSet
30.下列关键字能和try语句一起使用的是( CD )
A. final
B. finalize
C. finally
D. catch
31.下面程序的运行结果是( C )
FileOutputStream fos = new FileOutputStream(“c:\demo.txt”);
fos.write(“abc”);
fos.close();
A．在C盘创建文件demo.txt,但文件是空的
B．在C盘创建文件demo.txt,并写入数据abc
C．将C盘已有的文件demo.txt中追加写入abc
D．编译失败
32.下列关于Java中文件输入输出的说法正确的是（ AC ）
A. 在Java中，文件的输入输出功能是通过流来实现的
B. 如果要把数据写入到一个文件中，需要创建一个输入流对象
C. 字符流在某些方面比如汉字的处理，比字节流更方便
D. 可以通过Reader r = new Reader(“c:\pet.txt”)创建一个输入流对象
33.请看如下代码：
BufferedReader br = new BufferedReader(new FileReader("c:\\a.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("d:\\b.txt"));
String line = null;
while ((line = br.readLine()) != null) {
bw.write(line);
bw.newLine();
bw.flush();
}
bw.close();
br.close();它表达的意思是?（ A ）
A. 把c盘目录下的a.txt文件内容复制到d盘目录下的b.txt
B. 把d盘目录下的b.txt文件内容复制到c盘目录下的a.txt
C. 读取c盘目录下a.txt文件，输出在控制台
D. 把控制台的内容写入到d盘目录下的b.txt文件中
34.下列哪个关键字可以用于实现同步？( C )
A. native
B. static
C. synchronized
D. abstract
35.下列哪些方法可以让线程中断? ( AD )
A. sleep
B. start
C. notify
D. wait
36.启动线程调用哪个方法? ( B)
A. run()
B. start()
C. play()
D. go()
37.下面哪项不是TCP的特点? ( B )
A．面向连接
B．数据不可靠
C．传输速度慢
D．对数据大小无限制
38.TCP协议的服务器的Socket对象是下面哪一个类? ( C )
A．Socket
B．InputStream
C．ServerSocket
D．OutputStream
39.正则表达式中可以表示所有的单词字符信息的是下面哪个规则：( C )
A． \W
B． \w
C． [a-zA-Z]
D．[a-zA-Z_0-9]
40.获取Class类型的对象的三种方式是：( ABD )
B. class静态属性
A. Object类的getClass()
D. Class类的forName()静态方法
C. 自己创建Class对象
编程：（4*5）
1. 把c:\a.jpg复制到d:\b.jpg(任意一种方式实现即可)
package org.westos_homework;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
/**
* 把c:\\a.jpg复制到d:\\b.jpg(任意一种方式实现即可)
*
* 分析： 使用字节缓冲流，一次读取一个字节数组
*
* @author 小鑫
*
*/
public class HomeWork1 {
public static void main(String[] args) throws IOException {
// 封装数据源
FileInputStream fis = new FileInputStream("C:\\a.jpg");
// 封装目的地
FileOutputStream fos = new FileOutputStream("D:\\b.jpg");
//一次读取一个字节数组
byte[] bys=new byte[1024];
int len=0;
while((len=fis.read(bys))!=-1){
fos.write(bys, 0, len);
fos.flush();
}
fis.close();
fos.close();
}
}
- HashMap的键是Integer,值是String，存储三对元素，并遍历。(根据键找值的方式遍历)
package org.westos_homework;
import java.util.HashMap;
import java.util.Set;
/**
* HashMap的键是Integer,值是String，存储三对元素，并遍历。(根据键找值的方式遍历)
*
* @author 小鑫
*
*/
public class HomeWork2 {
public static void main(String[] args) {
//创建HashMap集合
HashMap hm = new HashMap();
//添加元素
hm.put(3, "韦德");
hm.put(1, "麦迪");
hm.put(24, "科比");
//获取键集合
Set keySet = hm.keySet();
for (Integer key : keySet) {
String value = hm.get(key);
System.out.println(key+"---"+value);
/*1---麦迪
3---韦德
24---科比*/
}
}
}
3.键盘录入5个数字，使用冒泡排序进行排序
package org.westos_homework;
import java.util.Arrays;
import java.util.Scanner;
/**
* 键盘录入5个数字，使用冒泡排序进行排序
*
* @author 小鑫
*
*/
public class HomeWork3 {
public static void main(String[] args) {
// 键盘录入
int count = 0;
int[] arr = new int[5];
// 循环输入5个整数
while (count < 5) {
Scanner sc = new Scanner(System.in);
try {
// 输入整数放到数组中
System.out.println("请输入第" + (count+1) + "个整数");
arr[count] = sc.nextInt();
count++;
} catch (Exception e) {
// 不是整数则走异常
System.out.println("请输入整数");
}
}
System.out.println("排序前的数组是" + Arrays.toString(arr));
// 冒泡排序，两两比较，大的往后移
for (int x = 0; x < arr.length - 1; x++) {
for (int y = 0; y < arr.length - 1 - x; y++) {
// 判断
if (arr[y] > arr[y + 1]) {
int temp = arr[y];
arr[y]=arr[y+1];
arr[y+1]=temp;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
4.请在main方法里面实现统计一个字符串的英文大写字符，英文小写字符及数字字符分别有多少个的程序代码，并输出统计结果。
package org.westos_homework;
import java.util.Scanner;
/**
* 请在main方法里面实现统计一个字符串的英文大写字符，英文小写字符及数字字符
* 分别有多少个的程序代码，并输出统计结果。
* @author 小鑫
*
*/
public class HomeWork4 {
public static void main(String[] args) {
//键盘录入
Scanner sc = new Scanner(System.in);
String line = sc.nextLine();
char[] ch = line.toCharArray();
//定义统计变量
int upperCount=0;
int lowerCount=0;
int numberCount=0;
for(int i=0;iif(Character.isDigit(ch[i])){
numberCount++;
}else if(Character.isLowerCase(ch[i])){
lowerCount++;
}else if(Character.isUpperCase(ch[i])){
upperCount++;
}
}
System.out.println("数字个数有"+numberCount+"个");
System.out.println("小写字符个数有"+lowerCount+"个");
System.out.println("大写字符有"+upperCount+"个");
/*dfsf55MKDD4dsD
数字个数有3个
小写字符个数有6个
大写字符有5个*/
}
}