【无标题】

最新推荐文章于 2024-01-18 23:25:36 发布
最新推荐文章于 2024-01-18 23:25:36 发布
阅读量266 收藏
点赞数 2
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/oxlandlzh/article/details/123145715
版权

Java笔记 新

快捷键：Alt + Ins

​ Ctrl + Alt + T

* 内容扩展 （ (提高开发效率，增加可扩展性)）

1. static

[Java中的static关键字解析 - Matrix海子 - 博客园 (cnblogs.com)]

在《Java编程思想》P86页有这样一段话：

“static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。”

这段话虽然只是说明了static方法的特殊之处，但是可以看出static关键字的基本作用，简而言之，一句话来描述就是：

方便在没有创建对象的情况下来进行调用（方法/变量）。

很显然，被static关键字修饰的方法或者变量不需要依赖于对象来进行访问，只要类被加载了，就可以通过类名去进行访问。

static可以用来修饰类的成员方法、类的成员变量，另外可以编写static代码块来优化程序性能。

1）static方法

static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。（但是非静态成员方法中可以访问静态成员方法或者变量）

public class lzh(){
2.
{
//匿名代码块
}
1.
static{
//静态代码块
}
3.
public lzh{
//无参构造器
}


}
//  1 2 3 为执行顺序

总结： static不能用非static的东西 而非static的方法可以用static的属性和方法

子承父类 父类static的方法可以直接调用 非static的方法需要super再调用 非子父关系需要new一个新的对象再调用

2. 抽象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hxzmtbQn-1645840885329)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\抽象.png)]

3. 接口

关键词： interface implements

interface：接口的创建

implements：编译接口（可多个）

public interface 接口名(){

}

public class 编译接口的文件名，一般为接口名后面加Impl   implements   接口名（可多个接口） {
//实现了接口的类必须重写接口的方法
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RScb5S6Y-1645840885331)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\接口.png)]

  • interfac 和 extends的区别

    即接口和抽象类的区别： 接口可以实现多继承

4.内部类

public class lzh{

    class InnerLzh{
        //内部类   还有很多种....
    }
    
}

* 重点补充

0. 继承之后 构造器以及方法的调用 补充和总结（重点！！！）\

1.方法的调用 以及 子承父类方法的调用

情况1. 当父类子类方法都是public时 子类和父类的方法均可用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vOAEQV0I-1645840885332)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\继承调用总结.png)]

情况2. 当方法都是自己类里面的，需要调用自己类的方法，也需要在”psvm“即public static void main(String[] args){} 中new自己类名的对象出来即

public static void main(String[] args){
lzh1 xxx = new lzh1();
//所创建对象的类名   对象名   =   new   类名();
}

package LZH;

import LZH.constructor.lzh1;

public class lzh1son extends lzh1 {    private String name;
    public lzh1son() {
    }
    public lzh1son(String name) {

        System.out.println(name);
    }
    public  void son(String name){
        System.out.println(this.name);
    }
    public void son1(){
        System.out.println(this.name);
    }

    public static void main(String[] args) {
        lzh1son lzh1son = new lzh1son();
        lzh1son.son("lzh");
//就算方法都是自己的，在静态里面也要new自己类的对象出来才能使用自己的方法
    }
}

情况2. 有static的区别以及没有的区别

先熟悉static有什么用

[Java中的static关键字解析 - Matrix海子 - 博客园 (cnblogs.com)] (里面包含很多题目解释)

“static方法就是没有this的方法。在static方法内部不能调用非静态方法，反过来是可以的。而且可以在没有创建任何对象的前提下，仅仅通过类本身来调用static方法。这实际上正是static方法的主要用途。”

这段话虽然只是说明了static方法的特殊之处，但是可以看出static关键字的基本作用，简而言之，一句话来描述就是：

方便在没有创建对象的情况下来进行调用（方法/变量）。 static不需要new对象

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fGyCzS9k-1645840885332)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\static2.png)]

没有static的方法需要调用时需要new一个新对象出来。 如下图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-rh6drdDM-1645840885333)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\static.png)]

1. 数组的使用

int[] group = new int[6];//这里的6代表group这个数组里面有6个数。
     group[0] = 1;//这里的0代表数组的下标，下标从0开始。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iAWUb8Wh-1645840885334)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\数组概念…png)]

2. break和return的用法

break：一般用于switch （case的结尾）
结束这个循环

return：结束方法，返回一个结果。
int…类型的方法后面都要有一个返回值，void则不用

3. new

4. 冒泡排序

package LZH.group;

import java.util.Arrays;

public class lzh2 {
    public static void main(String[] args) {
int[] m = {12,34,23,2,54,6,1};
         sort(m);
        System.out.println(Arrays.toString(m));
    }
    //由小到大排序数组
    public static int[] sort(int[] array){
        int t =0;
        for (int i = 0; i < array.length-1 ; i++) {
            for (int j = 0; j < array.length-1; j++) {
                if (array[j]>array[j+1]){
                    t = array[j];
                    array[j]=array[j+1];
                    array[j+1] = t;


                }

5. hasNext的用法

  • hasNext（） 是检测 还有没有下一个输入 有则为true hasNext要搭配next使用

  • next（）是指针移动到当前下标，并取出下一个输入

  • while (scanner.hasNextInt()){  //判断是否还有int整型输入
    int x = scanner.nextInt();//如果上面为true则x=输入的int
}

  • nextLine（） 把指针移动到下一行 让然后取出当前这一行的输入

  • hasNextLine（） 是检测下一行有没有输入 有则为true

6.ASCII码

常用：0-9 48-57

​ A-Z 65-90

​ a-z 91-122

        String c2 = "90x";
        char c1 = c2.charAt(2);
        int c4 = c2.codePointAt(2);
        int c = 57;//数字9 ASCII码
        int c3 =48;//数字0
        int c5 = 120;//英文x 转换为ASCII码为120    *具体可看ASCII表
        System.out.println(c1);
        System.out.println(c4);
        System.out.println(c1==c5);

输出结果为

x
120
true

7. 不知道叫什么

String a = "123ab";
String b = "4563";
int n = 0;
char a0 = a.charAt(0);//找字符串下标0的数
int a1 = a.codePointBefore(1);//找字符串下标1的钱一个数
int a2 = a.codePointAt(3);//找出下标为3即第4个数，并将其转换成十进制，英文符号查看ASCII码
int a3 = a.codePointCount(0,n);//这句话的意思是从0开始数到n有多少个数
int a4 = a.compareToIgnoreCase(b);//不常用，用的时候再查
//compareTo()比较字符串  具体看超链接https://www.php.cn/java/base/475681.html

        System.out.println(a0);
        System.out.println((int)a0);
        System.out.println(a1);
        System.out.println(a2);
        System.out.println(a3);
        System.out.println(a4);

1    //输出结果
49
49
97
0
-3

[java compareto方法有什么用-Java基础-PHP中文网]

8.Bool

boolean a = false;
if(a)//判断a是否为    
if(a==true)//同理上边    
if(a=true)//这样a必定为true

9.Public

Pubilc：公共的，权限比没有public的高

10.instanceof

  • 判断两个类存不存在子父类关系

System.out.println( x instanceof y ); // x --> y 能不能编译通过

11. throw 与 throws

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bOXiS7ZQ-1645840885335)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\异常.png)]

  • Throwable 包含所有异常

Java throws用于方法头，表示的只是异常的申明，而throw用于方法内部，抛出的是异常对象。throws抛出异常时，它的上级（调用者）也要申明抛出异常或者捕获，不然编译报错。而throw的话，可以不申明或不捕获（这是非常不负责任的方式）但编译器不会报错。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-yYmVn4m4-1645840885335)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\错误异常.png)]

try{

}catch{

}finally

}

12. 访问权限

在Java中能够影响到访问权限的只有 private、public、protected（包括包访问权限）这几个关键字。

13. 类里面的执行顺序（面试题）

static > {匿名块} > 构造器

当调用的类有父类时

static（父）> static（子）> {父} > {子} > 构造器（父）> 构造器(子)

概念

包机制

import  xxx.xxx.xxx  //调用
package xxx.xxx.xxx //包

逻辑运算符和三元运算符的用法

//      与 &&   或 ||   非 ！    （逻辑运算符）
        boolean a = true;
        boolean b = false;
        System.out.println(a&&b);
        System.out.println(a||b);
        System.out.println(!(a&&b));

输出结果为
false
true
true

//  x ？ y ：z    若x == true； 则输出y，否则输出z。   （三元运算符）
        boolean a =true;
        boolean b =false;
        int c = 10;
        int d = 100;
        System.out.println(a?c:d);
        System.out.println(b?c:d);

输出结果为
10
100

方法的概念以及应用

/*
修饰词           返回值类型             方法名（...）{
//方法体
return    返回值；
}
*/
//比较a和b的大小
public static int max(int a,int b){//public为修饰词，int为返回值类型，max为方法名
    System.out.println(a>b?"a>b":"a<b");//方法体
        return 0;//返回
}
1. 方法注意事项
  1. public static int lzh10(int... i){   //运用方法时   int ....    结尾需要返回 return
    System.out.println(i[0]);
        return 0;

    public static void lzh11(int... z){   //方法运用void时不需要返回
    System.out.println(z[0]);
           
}
2. 方法调用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0yFPimhp-1645840885336)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\方法调用.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vEXItJTY-1645840885336)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\方法调用1.png)]

上面两张图的意思为：lzh5类 调用了 lzh3类 的 llzh1方法

升级版 原理同上图

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-M7vgXVW0-1645840885337)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\方法调用2.png)]

注意：在不同包里面的方法调用 必须载入调用类的包 如上图 import

黄色框框：调用的方法名

红色框框：调用的类名

方法 存在类里面

静态（static）方法调用：类名+方法名()；

非静态方法的调用

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1MwpWuhW-1645840885338)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\非静态方法.png)]

递归

(能不用就不用，用的话数值要小)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fbItOFWi-1645840885339)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\递归注意1.png)]

案例1.

int n = 2;  //使用递归输入的值不能过大
        System.out.println(f(n));
    }
public static int f(int a){      //求a+(a-1)+(a-1-1)+.....+0
        if (a==0){return 0;}
        else {return a+f(a-1);}  //a+f(a-1)....f(1)+f(0)
}//记住运行完要结束递归

类

类的概念：[Java 对象和类 | 菜鸟教程 (runoob.com)]

1. 常用类
1. String

**String(byte[] bys)😗*通过字节数组创建字符串
**String(char[] chs)😗*通过字符数组创建字符串

char[] chars = {'1','2','3'};
        String s = new String(chars);
        String s1 = new String(chars);
        System.out.println(s==s1);
        System.out.println(s);
        byte[] bytes ={49,50,51};
        String s2 = new String(bytes);
        String s3 = new String(bytes);
        System.out.println(s2==s3);
        System.out.println(s2);

false
123
false
123

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UTiecurr-1645840885339)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\String常用API.png)]

2. Random

生成随机数

// new Random();

  Random random = new Random();
        for (int i = 0; i<10;i++ ) {
            //bound里面的数字为0-100  外面再加100  即为100-200的范围
            int num = random.nextInt(101)+100;
            System.out.println(num);
        }

​ 随机数的创建 以及 减加方法去处理非0开始的随机数

​ bound：10 意思为 0-9的数

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZkzCFc25-1645840885340)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\随机数Random.png)]

3.equaals

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KifZD74W-1645840885341)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\equals.png)]

概念理解

构造器概念原理 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HVQo58K1-1645840885341)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\3.png)]
package LZH.game;

public class lzh {//一个类  类名为lzh
    //1.属性，字段
    String name;
    int num1;
    //2.方法
    public void lzh(){
        System.out.println("woaini");
    }
    //一个类里面只存在属性和方法
    //=======================================
public lzh(){

}//无参构造器

   }

常用类

1. Array

常用

  1. Arrays.sort(a) 排序数组升序
  2. Arrays.toString() 打印数组

面向对象 OOP

对象是什么？

对象就是new出来的东西 就是new一个类在别的地方使用

类名     对象名   =    new 类名();

面向对象的本质 ：以类的方式组织代码，以对象的形式（封装）数据。

面向对象的三大特征：封装，继承，多态。

方法和构造器的调用，主程序输入的值只会进行值传递

如果想输出经过方法后得到的值 方法必须返回一个值

1. 类与对象的创建，构造器

构造器分为：无参构造器和有参构造器

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YKtMGwRr-1645840885342)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\super.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-810eQYat-1645840885349)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\2.png)]

（构造器和方法调用的区别解释）
package constructor;

public class lzh1 {
 
    String name;
    int age;
       public lzh1() {
    }//无参构造器
    public lzh1(String name, int age) {//有参构造器
        this.name = name;
        this.age = age;
        System.out.println("名字叫"+name+"\n年龄为"+age);
    }



}

package constructor;

public class test {
    public static void main(String[] args) {
        lzh1 lzh = new lzh1();
        lzh.age = 20;
        System.out.println(lzh.age);
        System.out.println("=======================");
        lzh1 person = new lzh1("lzh",20);//new一个新的类   寻找lzh1这个类里面包含String和int类型的构造器
        System.out.println("=======================")
        lzh1 person1 = new lzh1("oxl",20);    //  构造器跟方法调用的区别
    }                                         //  构造器只能new出来后面加变量  例如: lzh1 person = new lzh1("lzh",20);
                                              //  方法则是  用  .   点出来    例如； 
}


/*输出结果
20
=======================
名字叫lzh
年龄为20
=======================
名字叫oxl
年龄为20

Process finished with exit code 0

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Hgj9pxL6-1645840885350)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\方法跟构造器.png)]

红色框框：方法名 以及 方法的调用 格式: 新建一个类名 . 新建类里面的方法();

黄色框框：类名

绿色框框：不同包 需要调用 其他包里的类

总结

构造器：1.和类名相同
2.没有返回值

作用：1.new的本质就是调用构造器
2.初始化对象的值

注意点：定义了有参构造之后如果想使用无参构造，那么要显示的定义一个无参构造。

All + Insert 生成构造器的快捷键

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4qpA9Uks-1645840885351)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\1.png)]

2.封装 （对类的封装）

  • 该露的露，该藏的藏

    我们程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据细节由自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用。

  • 封装（数据的隐藏）

    通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

  • 记住这句话就够了：属性私有（private），get/set

package LZH.OOP;
//private私有化，必须通过调取才能得到
public class lzh {
private String Name;
private int age;
private char sex;

    public lzh() {}
//get/set   get得到   set设置
    public String getName() {
        System.out.println(Name);
        return Name;
    }

    public void setName(String name) {
        Name = name;
    }

    public int getAge() {
        if (age!=0){
            System.out.println(age);
        }else {
            System.out.println("输入的年龄不合法！");
        }
       return 0;
    }

    public void setAge(int age) {

this.age = age;
    }

    public char getSex() {
        System.out.println(sex);
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }
}

import LZH.OOP.lzh;
public class Application {
    public static void main(String[] args) {
        lzh lzh = new lzh();//调用上面的类   主程序简洁易读
        lzh.setName("lzh");
        lzh.setAge(8);
        lzh.setSex('男');
        lzh.getName();
        lzh.getAge();
        lzh.getSex();
    }
}
3. 继承 （子承父类）

关键词：extends super object类 方法重写

object是所有类的父类

extends 的用法

public class student extends Person{
//student 继承 Person的东西
}

super (子类调用父类的东西) 东西：1.属性 2.方法 只能在方法或者构造器中调用

this.name; //子类的属性名
super.name; //父类的属性名
name;  //主程序输入的值

方法重写

  • 子类和父类的方法名必须一致

  • 方法重写优先用子类的新方法。

注意事项：如果方法为静态（Static）则用本地的test 即 father.test 会输出 father Static 和 final（常量）都不能被重写

重写的关键：public > protected > private(为私有的不能被重写)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YlX2tnmK-1645840885351)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\重写.png)]

//输出结果
//son
//son

   @Override  // Alt + ins 直接生成重写
    public void test() {
        super.test();//调用父类的方法

快捷键重写： Alt + Ins

4. 多态

Father f1 = new son();

注意：1. 多态是方法的多态，属性没有多态性。

​ 2. 父类引用指向子类对象但不能使用子类独有的方法。 可用方法 = 子类重写 + 父类自身的方法 ***** 除非强行转换，后面会学

((lzh1son) lzh1).test1();// 把父类强转成子类然后调用子类的方法 (高转低)
lzh1 lzh1 = lzh1son; //低转高不用加括号 把子类转换成父类



- 强转的目的是方便方法的调用！  使程序变得简洁！

- 多态存在的条件

有继承关系

子类**重写**父类的方法



[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7y0Q5FZF-1645840885352)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\多态1.png)]



红色框框：父类引用指向子类，但不能使用子类独有的方法，**只能使用子类重写的方法**。

## 习题

### 1. 输入一个字符串，找出里面的数字并排成出一个数组

```java
package LZH.game;

import java.util.Arrays;
import java.util.Scanner;
//识别一串字符串，组成数组
public class lzh2 {
  public static void main(String[] args) {
      boolean a = true;
      while (a){
      Scanner scanner = new Scanner(System.in);
      String nums1 = scanner.nextLine();
      int sum = 0;
      int[] group = new int[find(sum,nums1)];//调用find的方法，new一个在find里面执行完毕的sum
      System.out.println(Arrays.toString(ProcessGroup(group,nums1)));
      }

}
public static int find(int sum,String nums1){    //计算有多少个数组
    char c;
    boolean judge = true;
      for (int i = 0; i < nums1.length(); i++) {
      for (int j = 48; j <= 58; j++) {
          c = nums1.charAt(i);
          if (j==58){ judge = true;}
          if (c==j){
              if (judge){
                  sum++;
                  judge = false;
              }
              break;
          }
      }
  }
  return sum;//返回sum值
}
public static int[] ProcessGroup(int[] group,String nums1){
      int count = nums1.length()-1;
      int multi = 1;
      int sum = -1;
      boolean judge1 = false;
      boolean judge = true;
      char c;
  for (int i = group.length-1; i >= 0; i--) {
     while (count>=0&&count<nums1.length()) {
         c = nums1.charAt(count);
         for (int k = 48; k <= 58; k++) {
             sum++;
             if (c == k) {
                 judge = true;
                 if (c == k && judge) {
                     group[i] += sum * multi;
                     multi *= 10;
                     sum = -1;
                     judge1 = true;
                     break;
                 }
             }
             if (k == 58) {
                 multi = 1;
                 sum = -1;
                 judge = false;
             }
         }
         if (judge1&&multi==1){count--;judge1=false;break;}
         count--;
     }

  }

return group;
}
      }

2.围圈圈

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-v992jAcl-1645840885353)(C:\Users\oxlan\OneDrive\新Java笔记\java笔记图片\习题.png)]

package LZH;

import java.util.Arrays;
import java.util.Scanner;
import LZH.test;
public class test2 {
    public static void main(String[] args) {
        test test = new test();
        int[] group = new int[0];

        while (true) {

            Scanner scanner = new Scanner(System.in);
            int num = scanner.nextInt();
            group = new int[num];
            for (int i = 0; i < group.length; i++) {
                group[i]=i+1;
            }
            System.out.println(Arrays.toString(test.group(group)));
        }
    }
}


package LZH;
public class test {
public int[] group(int[] group){
    int count = 0;
    int count2 = 0;
  do{
      count2=0;
      for (int i = 0; i < group.length; i++) {
          if (group[i] != 0) {
              count2++;
          }
      }
if (count2!=1){
       for (int i = 0; i < group.length; i++) {
           if (group[i]!=0){ count++;}
           if ((count)%3==0&&count!=0){
               count2--;
               count = 0;
               group[i]=0;
               continue;
           }
           if (count2==1){break;}
       }
}
   }while (count2!=1);
return group;
}
    }

3. 验证码(equals可以直接比较字符串)

只是比较地址 new的话对象不同所以！= 直接创建如 String s1 String s2 内容就

package LZH;

import java.util.Arrays;
import java.util.Scanner;
import LZH.test;
public class test2 {
    public static void main(String[] args) {
        test test = new test();
        String code = "";
        System.out.println();
        while (true) {
            String code1 = test.code(code);
            System.out.println("验证码为："+code1);
            System.out.print("请输入验证码：");
            Scanner scanner = new Scanner(System.in);
            String inputCode = scanner.nextLine();
 /* char c;
  char b;
  int count = 0;
            for (int i = 0; i < code1.length(); i++) {
                c = code1.charAt(i);
                b = inputCode.charAt(i);
                if (b==c){
                    count++;
                }
            }*/
            //count==5
  if (code1.equals(inputCode)){
      System.out.println("输入正确！");
      System.out.println("========================");
  }else{
      System.out.println("输入错误！");
      System.out.println("========================");
  }

        }

    }
}

package LZH;

import java.util.Random;

public class test {
public String code(String code){
    Random random = new Random();
    int b = random.nextInt();
    int count = 0;
    char c;
    while (count<5) {
        int a = random.nextInt(3);
        switch (a){
            case 0:b = random.nextInt(10)+48;
            c = (char)b;
            code+=c;
            count++;
            break;

            case 1:b = random.nextInt(26)+65;
            c = (char)b;
            code+=c;
            count++;
            break;

            case 2:b = random.nextInt(26)+97;
            c = (char)b;
            code+=c;
            count++;
            break;

        }

    }

return code;
}



    }
oxlandlzh
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Qt-无标题窗口
学而思
05-21 7402
        今天学习了下无标题窗口，于是来记录下我的学习过程首先建立一个Qt Widgets Application继承QWidget类创建完后直接运行就得到了如下效果那么，既然是无标题窗口就要去掉窗口栏啊，于是加上setWindowFlags(Qt::FramelessWindowHint | Qt::WindowMinimizeButtonHint);去掉标题栏，但是这样整个窗口就不能移动...
Qt无标题窗口
05-21
在本文中，我们将深入探讨如何使用Qt框架创建一个无标题窗口，这在界面设计和自定义标题栏美化中非常有用。我们将关注`framelesswidget.cpp`、`main.cpp`、`framelesswidget.h`等核心文件，理解它们在实现无标题窗口...
继承的书写格式
weixin_43737594的博客
09-05 178
继承:子类对象可以使用父类中的属性或方法的过程,叫做继承 格式: class 子类名(父类名): object是所有类的公共父类,基类,顶级类 如果使用经典类,或者新式类中括号内什么也不写,其实默认就继承了object class Person(object): pass class Man(Person): pass class Boy(Man): pass ...
Python七(继承)
ckg3824278的博客
09-06 203
一、继承 继承的语法是在方法名后加个括号，在括号中写要继承父类的名字。在Python中，object类是所有类的基类（定义一个类没有指定继承哪个类，就默认继承object类）。 #!/usr/bin/python #coding=utf-8 #定义一个父类 class Employee(object): def __init__(self, name): self.__name = name def get_name(self): return self._
C#中实现无标题栏窗体拖动的代码
热门推荐
百锦再的博客
01-18 1万+
事件来实现拖动功能。当鼠标按下时，我们标记鼠标正在拖动，并保存当前坐标。在鼠标移动时，如果鼠标正在拖动，我们更新窗体的位置，使其跟随鼠标移动。当鼠标释放时，我们取消拖动标记。请注意，在窗体上添加了对应事件处理程序的窗体控件属性应该设置为对应的事件处理程序方法。在窗体设计视图，选择属性窗格，在事件选项卡中为。在C#中实现无标题栏窗体拖动的代码可以通过处理鼠标事件来实现。这样，当你在运行窗体时，你就可以通过鼠标拖动窗体来改变其位置。事件分别选择对应的处理程序方法。在这个示例代码中，我们通过处理。
C# 移动无标题栏无边框窗体的3种方法
SabreWulf
03-13 2259
目录 第一种：手工移动 第二种：调用系统API 1.引入下面代码 前提需要引入命名空间using System.Runtime.InteropServices 2.增加鼠标按下事件发送消息，让系统误以为按下是标题栏 第三种，重写 WndProc 第一种：手工移动 直接通过修改窗体位置从而达到移动窗体的效果 //定义一个位置信息Point用于存储鼠标位置 private Point mPoint; /// <summary>
Qt实现改变无标题栏窗体大小及移动窗体
danshiming的博客
11-10 3250
Qt实现鼠标左键拖动无标题栏窗体右下角改变窗体大小及移动窗体
Chrome显示无标题错误代码STATUS_INVALID_IMAGE_HASH
precy_wm的博客
01-03 1348
Chrome显示无标题错误代码STATUS_INVALID_IMAGE_HASH
WIN32无标题栏窗口移动方法种种
ZDT_zdh的博客
11-02 2003
WIN32无标题栏窗口移动方法种种 转载来源：http://blog.csdn.net/fuyun_cloud/article/details/8008197     首先，看看在正常情况下系统是怎样来移动程序窗口的。当使用者在程序窗口标题栏区域（非工作区）内，按下鼠标左键时将会发生下列事情：  ◆ 系统向该窗口过程函数发送WM_NCLBUTTONDOWN消息。  ◆ WM_NC...
Chrome 无标题 哭脸 已崩溃
wkj52719的博客
05-24 4437
谷歌浏览器chrome突然打开后任何页面均显示为无标题，哭脸。鼠标选中sheet页面时，提示已崩溃。 无法打开设置、开发工具箱 经过检查，是chrome的Userdata数据出错，导致页面加载无法正常展示页面。 修复办法： 打开文件夹C:\Users\{privateUserId}\AppData\Local\Google\Chrome，删除User data文件夹，如果需要备份UserData,请备份User Data到其他地方。 ...
VC去掉'无标题'字样的方法.zip
11-21
在使用Visual C++进行编程时，我们经常会在创建新的窗口或者对话框时默认看到标题栏显示为“无标题”。这可能会对用户界面的美观性和专业性造成一定的影响。本资料包提供了一种方法来帮助开发者去掉这个“无标题”...
visual c++取掉对话框窗口的 -无标题 字样的方法
08-04
在Visual C++编程环境中，创建窗口应用程序时，默认情况下，窗口标题栏可能会显示“-无标题”字样，这通常是由于没有正确设置窗口类或没有自定义窗口标题所导致的。要解决这个问题，我们需要深入理解Windows API中的...
c#实现无标题栏窗口的拖动
09-05
本篇文章将详细讲解如何在C#中实现这种无标题栏窗口的拖动以及其他基本操作。 首先，为了实现无标题栏窗口的拖动，我们需要处理窗体的鼠标事件。窗体的`FormBorderStyle`属性应设置为`None`，这会去除窗体的边框和...
delphi 无标题调整大小
11-26
在Delphi编程环境中，"无标题调整大小"通常是指创建没有标准标题栏的窗口，并允许用户通过拖动边界来调整其大小。这种设计通常用于自定义界面或创建无边框的对话框。以下是对这个主题的详细解释： 一、创建无标题...
Android 全屏无标题栏的三种实现方法
09-02
在Android应用开发中，有时我们需要实现全屏无标题栏的效果，以提供更加沉浸式的用户体验。以下将详细介绍三种在Android中实现全屏无标题栏的方法。 ### 方法一：通过Java代码 在Activity的`onCreate()`方法中，在...
无标题1123231212321
07-17
无标题1123231212321
无标题111111111111
最新发布
07-21
11111111
无标题1111111111111111111111111111
07-05
111111
设置无标题 android
05-02
在Android应用中，设置无标题是一种简洁和美观的设计方式，可以为用户提供更流畅的使用体验。以下是一些实现设置无标题的方法： 1. 在Android的Manifest文件中，找到对应Activity的标签，并添加”android:theme="@android:style/Theme.NoTitleBar"“属性。这样可以通过Android自带的主题去掉标题栏。 2. 使用自定义的主题，可以在样式表中添加以下代码： <style name="AppTheme" parent="Theme.AppCompat.NoActionBar"> <!-- ...其他样式... --> </style> 这种方式可以通过设置主题去除ActionBar和标题栏，同时保留其他布局元素。 3. 去掉代码中的setTitle()方法，这是一种最简单的方法，通过不设置Activity的标题来实现无标题。 以上就是三种常见的实现Android无标题的方式，开发者可以根据实际需求进行选择。值得注意的是，去除标题栏可能会影响用户的导航体验，因此在设计上需要考虑周全。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值