JAVA基础笔记

最新推荐文章于 2023-02-20 14:02:43 发布
最新推荐文章于 2023-02-20 14:02:43 发布
阅读量209 收藏
点赞数 1
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/h2221892477/article/details/126918263
版权

面向对象进阶

黑马程序员Java零基础视频教程(2022最新Java入门，含斯坦福大学练习题+力扣算法题+大厂java面试题）_哔哩哔哩_bilibili

0.5.方法概述

//三种访问权限

public class student {
    String name;
    private int age;
    static char sex;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public static char getSex() {
        return sex;
    }

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

//不添加修饰,可以直接.
//如果是static直接类名.
//如果是priveate，只能get或者set方法才能进行赋值
public class studenttest {
    public static void main(String[] args) {
        student.sex='男';
        student s1 = new student();
        s1.name="郝胜新";
        s1.setAge(21);
        //简单的调用，可以这么调用
        System.out.println(new student.name);
    }
}

一.static

1.静态成员变量

a1

public class a1 {
    public static void main(String[] args) {
        a2 name = new a2("郝胜新",21);
        name.student = "大飞老师";
        System.out.println(name.toString());
    }

}

a2

public class a2 {
    private String name ;
    private int age;
    public String  student;

    public a2() {
    }

    public a2(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "a2{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", student='" + student + '\'' +
                '}';
    }

    public a2(String name, int age, String student) {
        this.name = name;
        this.age = age;
        this.student = student;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getStudent() {
        return student;
    }

    public void setStudent(String student) {
        this.student = student;
    }
}

2.静态方法和工具类

工具类一般用private的构造方法，为了不让他创建对象

//工具类打印数组和求平均值

public class AyyayUtil {
    private AyyayUtil(){
        
    }
    public static void printArr(int[] array) {
        for (int i = 0; i < array.length; i++) {
            System.out.print(array[i]+" ");
        }
    }

    public static void getAerage(float[] array) {
        float sum = 0;
        for (int i = 0; i < array.length; i++) {
            sum += array[i];
        }
        System.out.println("平均分为"+sum/array.length);
    }
}


测试类

public class TestDemo {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5, 6, 7, 8};
        float[] array2 = {1, 2, 3, 4, 5, 6, 7, 8};
        AyyayUtil.printArr(array);
        AyyayUtil.getAerage(array2);
    }
}

注意事项：静态方法中，只能访问静态成员变量，和调用静态方法。

​ 非静态方法可以访问所有的静态成员变量和静态方法

​ 静态方法中没有this关键字

​

二.继承

1.子类能继承父类中的哪些内容？

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YiD9vTLa-1663486103899)(E:\Typora\img\image-20220829092250821.png)]

  1. 创建一个子类对象，调用父类方法，不是逐级向上寻找，而是有一个虚方法表，把非private,fianl,static方法添加进去，然后直接调用，这样效率会高，如果有以上三个其中的一个，那么会向上逐级寻找

2.方法重写和注意事项机器要求

​ 1.重写方法的名称，形参列表必须与父类中的一致

​ 2.子类重写父类方法时，访问权限子类必须大于父类

​ 3.子类重写父类方法时，返回值类型子类必须小于等于父类

​ 4建议：重写的方法尽量和父类保持一致

​ 5.只有被添加到虚方法表的中的方法才能被重写

3.this,super

this();

:使用本类的构造方法，一般用于数据的初始化。

package 面向对象进阶._829extend1;

public class student {
    String name;
    int age;
    String school;

    public student(String name, int age, String school) {
        this.name = name;
        this.age = age;
        this.school = school;
    }
	//一般给数据初始化用的
    public student() {
        this(null,0,"科工大");
    }


}

三.多态

1.对象的多种形态

多态的前提

​ 1.有继承/实现关系

​ 2.有父类引用指向子类对象

​ 3.有方法的重写

多态的好处

​ 1.使用父类型作为参数时，可以接受所有子类对象

​ 2.体现多态的扩展性与便利

多态的弊端

​ 1.不能使用子类的特有功能

解决方法

​ 1.强制类型转换

最简单应用

public class Person {
    private String Name;
    private int Age;

    public Person(String name, int age) {
        Name = name;
        Age = age;
    }

    public Person() {
    }

    public String getName() {
        return Name;
    }

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

    public int getAge() {
        return Age;
    }

    public void setAge(int age) {
        Age = age;
    }
    public void show(){
        System.out.println("信息为："+getName()+","+getAge());
    }
}
class Admin extends Person{
    @Override
    public void show() {
        System.out.println("管理员信息为："+getName()+","+getAge());
    }
}
class Student extends Person {
    @Override
    public void show() {
        System.out.println("学生信息为："+getName()+","+getAge());

    }
}
class Teacher extends Person{
    @Override
    public void show() {
        System.out.println("老师信息为："+getName()+","+getAge());
    }
}

package 面向对象进阶._230_duotai;

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        student.setName("张三");
        student.setAge(21);

        Teacher teacher = new Teacher();
        teacher.setName("李四");
        teacher.setAge(41);

        Admin admin = new Admin();
        admin.setName("王五");
        admin.setAge(73);

        register(student);
        register(teacher);
        register(admin);

    }
    public static void register(Person p){
        p.show();
    }
}

2.多态调用成员的特点

变量调用：编译看左边，运行也看左边

方法调用：编译看左边，运行看右边

​ 编译的时候会看左边的父类中有没有这个方法，如果有编译成功，没有则编译失败

​ 运行的时候，运行的是右边的对象的方法

package 面向对象进阶._830_duotai;

public class AnimalTest {
    public static void main(String[] args) {
        Animal a = new Dog();
        System.out.println(a.name);--->动物
        a.show();--->Dog--show
    }
}

class Animal {

    String name = "动物";
    public void show(){
        System.out.println("Animal--show方法");
    }
}
class Dog extends Animal{
    String name = "狗";

    @Override
    public void show() {
        System.out.println("Dog--show方法");
    }
}
class Cat extends Animal{
    String name = "猫";

    @Override
    public void show() {
        System.out.println("Cat--show方法");
    }
}

多态的弊端，

​ Animal a = new Dog();

​ 因为运行看右边，所以没办法调用Dog自己方法

解决办法：强转

Animal a = new Dog();
Dog b = (Dog) a ;-->强转，如果是从小范围向大范围转换，就不用强转，Animal要比Dog的范围要小，别转成别的类型，否则报错

正确的转换方法

        Animal a = new Dog();
        if (a instanceof Dog){
            Dog  d = (Dog) a;
        }else if (a instanceof Cat){
            Cat C = (Cat) a;
        }else {
            System.out.println("没有这个类型，转换失败");
        }

遇到多态问题时，最好时从上往下写代码，

final

1.final修饰变量时，变量无法二次赋值

2.final修饰类时，方法无法被继承

3.final修饰方法时，方法无法被重写

权限修饰符

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-p0CJH7Kb-1663486103900)(E:\Typora\img\image-20220831094931292.png)]

代码块

{}里面的方法和变量，只能在{}中使用

static{}时用类时就运行一次，一般用于数据的初始化

public class test {
    static ArrayList<String> list = new ArrayList<>();
    static {
        list.add("张三");
        list.add("李四")
    }
    public static void main(String[] args) {
        {
            int a = 10;
            int b = 20;
            System.out.println(a);
            System.out.println(b);
        }
    }
    static{
        System.out.println("静态代码块执行了");
    }

}

调用main方法

test.main(null);

四.抽象类

1.抽象类不能实例化（）抽象方法，无法调用。

2.可以有构造方法

3.抽象类的子类

​ 要么重写抽象类中的所有抽象方法

​ 要么是抽象类

五.接口

接口就是一种规则，是对行为的抽象

1.接口用关键字interface来定义

​ public interface 接口名{}

2.接口不能实例化

3.接口和类之间是实现关系，通过implements关键字表示

​ public class 类名 implments 接口名 {}

4.接口的子类（实现类）

​ 要么重写接口中所有的抽象方法

​ 要么是抽象类

注意1：接口和类的实现关系，可以单实现，也可以多实现

​ public class [类名] implements 接口名1，接口名2{}

注意2：实现类还可以在继承一个类的同时实现多个接口

​ public class [类名] extend [父类] implements 接口名1，接口名2{}

特点

成员变量

​ 只能是常量

​ 默认修饰符public static final

构造方法

​ 没有

成员方法

​ 默认修饰符：public abstract

简单实现


public interface Inter {
    int a = 10;
    //默认修饰符 public static final
    void method();
}



public class Test implements Inter{
	public static void main(String[] args) {
        System.out.println(Inter.a);
    }
    @Override
    public void method() {
        System.out.println("method");
    }
}

在接口中使用默认的方法：

格式：public default 返回值类型 方法名(){}

注意事项：

​ 1.默认方法不是抽象方法，不强制重写。如果需要重写去掉default关键字

​ 2.public可以省略，但是default不可以
​ 3.如果实现了多个接口，多个接口中存在相同名字的默认方法，子类就必须对该方法进行重写

public interface Inter {
    default void method(){
        System.out.println("我是一个默认方法");
    }
}

六.内部类

在一个类里面，定义另外一个类

特点：

​ 内部类可以直接访问外部类的成员，包括私有

​ 外部类要访问内部类的成员必须创建对象

public class test1 {
    String name;
    int age;
    public class neibulei{
            String sonname;
            String sonage;

    }
}

public class temp {
    public static void main(String[] args) {
        //创建内部类对象
        test1.neibulei method = new test1().new neibulei();
        //调用内部类里的成员变量
        System.out.println(method.sonname);
        //快速调用
        System.out.println(new test1().name);
        
    }
}
其他的修饰方式：

​ private：其他类中就没有办法直接创建内部类的对象了

public class test1 {
    String name;
    int age;
    private class neibulei{
            String sonname;
            String sonage;

    }
}

怎么创建private修饰内部类的对象

public class test1 {
    String name;
    int age;
    private class neibulei{
            String sonname;
            String sonage;
    }
    public neibulei makemethod(){
        return new neibulei();
    }
}

public class temp {
    public static void main(String[] args) {
//        test1.neibulei method = new test1().new neibulei();
//        System.out.println(method.sonname);
        test1 test1 = new test1();
        Object o = test1.makemethod();
        System.out.println(new test1().name);

    }
}

注：给外部类创建一个方法，让方法返回一个内部类的对象，然后就可以创建一个内部类的对象了，但是返回值得用Object来接收

​ 默认：

只能在本包内创建对象，其他包无法创建

test

public class Outer {
    private int a = 10;
    static class Inner{
        private int a = 20;
        public void show(){
            int a = 30;
            System.out.println(new Outer().a); //10
            System.out.println(new Outer.Inner().a); //20
            System.out.println(a); //30
        }
    }
}
static

静态成员变量得调用



public class Outer {
    int a = 10;
    static int b = 20;
    //静态内部类
    static class Inner{
        //静态成员方法
        public static void show1(){
            System.out.println("非静态方法被调用了");
            //调用外部类非静态成员变量
            System.out.println(new Outer().a);
            //调用外部类静态成员变量
            System.out.println(b);
        }
        public void show2(){
            System.out.println("静态方法被调用了");
        }
    }
}



public class Test {
    public static void main(String[] args) {
        //因为是非静态成员变量，所以得用对象调用
        new Outer.Inner().show2();
        //是静态成员变量，能直接调用
        Outer.Inner.show1();
    }

}

局部内部类

//卸载方法里面的内部类

1.将内部类定义在方法里面就叫做局部内部类，类似于方法里面的局部内部类

2.外界无法直接使用，需要在方法内部创建对象并使用

public class Outer1 {
    int b =20;
    public void show(){
        int a = 10;
        class inner{
            String name;
            int age;
            public void mathod1(){
                System.out.println("局部类的method1方法");
                System.out.println(a);
                System.out.println(name);
            }
        }
    }
}

匿名内部类

匿名内部类本质上就是隐藏了名字的内部类

速记：new类名小括号中括号重写

整体是个对象！！！！

格式：
	new 类名或者接口名(){
		重写方法；
	}；
举例：
	Inter inter	 = new Inter(){
    //整体是个对象,中括号里面是一个类，没有名字的类，然后new一个中括号(没有名字得那个类/接口)对象，然后得告诉他new得是哪个类/接口对象，输入Inter，可以用		Inter类型来接收
		public ovid show(){
		}
	}

测试：

public interface swim {
    void swims();
}

public class Test {
    public static void main(String[] args) {
        swim s = new swim() {
            @Override
            public void swims() {
                System.out.println("我是一个傻瓜");
            }
        };
        s.swims();
    }
}

拼图游戏（可视化）

1.JFrame

		JFrame jFrame = new JFrame();        
		jFrame.setSize(800,800);//设置窗体大小
        jFrame.setDefaultCloseOperation(3);//程序关闭方式
        jFrame.setAlwaysOnTop(true);//一直在最上面
        jFrame.setLayout(null);//关闭位置信息
		jFrame.getContentPane()//获取内部窗体对象
        jFrame.setVisible(true);//设置为可见窗口

Ctrl + Alt + M 快速创建方法

2.菜单设计

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Le3VCb8x-1663486103901)(E:\Typora\img\image-20220908090945401.png)]

由jMenuBar，JMenu，JMenuItem

jMenuBar是一个菜单对象

JMenu是功能

JMenuItem是每一条信息

JMenuItem->JMenu->jMenuBar逐级添加

private void initcaidan() {
        //初始化菜单
        this.setVisible(true);
        //创建菜单对象
        JMenuBar jMenuBar = new JMenuBar();
        //创建菜单名字
        JMenu jMenu1 = new JMenu("功能");
        JMenu jMenu2 = new JMenu("关于我们");
        //下拉菜单的条目
        JMenuItem replay = new JMenuItem("重新游戏");
        JMenuItem relogin = new JMenuItem("重新登陆");
        JMenuItem closegame = new JMenuItem("关闭游戏");

        JMenuItem wechat = new JMenuItem("本人微信");

        //与选项关联
        jMenu1.add(replay);
        jMenu1.add(relogin);
        jMenu1.add(closegame);

        jMenu2.add(wechat);

        //添加到菜单中
        jMenuBar.add(jMenu1);
        jMenuBar.add(jMenu2);

        //把菜单放入界面中

        this.setJMenuBar(jMenuBar);
    }

3.添加图片

​ 创建jframe对象时，创建的是一个外框，里面的框是getContentPane（），直接把照片添加到里面就行了，就不用把添加到JFrame对象中

    private void initImage() {
        //创建一个图片ImageIcon的对象
        ImageIcon imageIcon = new ImageIcon("src/girl/Game/Image/taile.jpg");
        //创建一个jLabel的对象(管理容器，管理图片的容器)
        JLabel jLabel = new JLabel(imageIcon);
        //指定图片的位置
        jLabel.setBounds(0,0,201,201);
        this.getContentPane().add(jLabel);
        //把管理器添加到了界面中
    }

4.时间

​ 键盘监听

​ 使用流程：创建一个JButton对象->给JButton设置大小->添加事件->JButton添加到JFrame内部

package girl.Game.Test;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;

public class t4 extends JFrame implements ActionListener {

    JButton jButton1 = new JButton("按键1");
    JButton jButton2 = new JButton("按键2");

    public t4() throws HeadlessException {
        this.setSize(500,500);
        this.setLayout(null);
        this.setDefaultCloseOperation(2);
        this.setAlwaysOnTop(true);

        jButton1.setBounds(0,0,100,200);
        jButton2.setBounds(200,0,100,200);
        jButton1.addActionListener(this);
        this.getContentPane().add(jButton1);
        this.getContentPane().add(jButton2);
        this.setVisible(true);
    }
    @Override
    public void actionPerformed(ActionEvent e) {
        Object source = e.getSource();
        System.out.println("按钮已经点击");
        if (source==jButton1){
            jButton1.setBounds(0,0,100,100);
        }else if (source == jButton2){
            Random random = new Random();
            int i = random.nextInt(500);
            jButton2.setBounds(i,i,100,100);
        }
    }
}

​ 鼠标监听

package girl.Game.Test;

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

public class t5 extends JFrame implements MouseListener, ActionListener {
    public t5() throws HeadlessException {
        this.setSize(500,500);
        this.setDefaultCloseOperation(3);
        this.setLayout(null);
        this.setAlwaysOnTop(true);
        this.setVisible(true);
        JButton jButton = new JButton();
        jButton.setBounds(100,100,100,100);
        jButton.addActionListener(this);
        jButton.addMouseListener(this);
        this.getContentPane().add(jButton);

    }

    @Override
    public void mouseClicked(MouseEvent e) {
        System.out.println("单击");
    }

    @Override
    public void mousePressed(MouseEvent e) {
        System.out.println("按下不松");
    }

    @Override
    public void mouseReleased(MouseEvent e) {
        System.out.println("划入");
    }

    @Override
    public void mouseEntered(MouseEvent e) {
        System.out.println("划出");
    }

    @Override
    public void mouseExited(MouseEvent e) {

    }

    @Override
    public void actionPerformed(ActionEvent e) {

    }
}

​ 动作（键盘）监听

package girl.Game.Test;

import javax.swing.*;
import java.awt.*;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;

// 键盘监听
public class t6 extends JFrame implements KeyListener {
    public t6() throws HeadlessException {
        this.setSize(500,500);
        this.setDefaultCloseOperation(3);
        this.setLayout(null);
        this.setAlwaysOnTop(true);
        this.setVisible(true);
        this.addKeyListener(this);
    }

    @Override
    public void keyTyped(KeyEvent e) {

    }

    @Override
    public void keyPressed(KeyEvent e) {
        System.out.println("按下不松");
    }

    @Override
    public void keyReleased(KeyEvent e) {
        System.out.println("松开按键");
        int keyCode = e.getKeyCode();
        System.out.println(keyCode);
        if (keyCode == 65){
            System.out.println("按的是A");
        }else {
            System.out.println("按的不是A");
        }
    }
}

其他

//清除所有
this.getContentPane().removeAll();
//刷新
this.getContentPane().repaint();
//关闭虚拟机
System.exit(0);

弹窗

            System.out.println("弹出微信");
            //创建一个弹窗
            JDialog jDialog = new JDialog();
            //设置大小
            jDialog.setSize(300,300);
            //设置弹窗总在上面
            jDialog.setAlwaysOnTop(true);
            //设置句中
            jDialog.setLocationRelativeTo(null);
//            jDialog.setTitle("本人微信");
            //天窗不关闭，游戏没有办法操作
            jDialog.setModal(true);

            JLabel jLabel = new JLabel("没有帅哥");
            jLabel.setBounds(100,100,100,100);
            jDialog.getContentPane().add(jLabel);
            jDialog.setVisible(true);

输入框

字符串

1.StringBuffer

2.StringBuilder

        //1.创建一个StringBuilder容器的对象
        StringBuilder sb = new StringBuilder("初始化字符串");
        //2.可以添加任何类型，都会转变为字符串
        sb.append(11);
        sb.append('你');
        //3.反转字符串
        sb.reverse();
        System.out.println(sb);
        //4.toString,上面打印的是sb,sb是一个容器类型是StringBuilder,经过toString他才能变成String类型的字符串
        String str = sb.toString();
        System.out.println(str);

练习：写一个方法要求返回一个按照 [1,2,3,4,5,6,7,8,9,10] 返回的方法

		public static String method(int [] array){
        StringBuilder sb = new StringBuilder("[");
        for (int i = 0; i < array.length; i++) {
            if (i != array.length - 1){
                sb.append(array[i]);
                sb.append(",");
            }else {
                sb.append(array[i]);
            }

        }
        sb.append("]");
        return sb.toString();
    }

3.StringJoiner

.StringBuilder太麻烦了，拼接，和[ ]那就用StringJoiner

两种方法
public StringJoiner(间隔符号)
public StringJoiner(间隔符号,开始符号，结束符号)

七.常用API

Math

//向上取整
Math.ceil(double a);
//向下取整
Math.floor(double a);
//圆周率
Math.E;
//四舍五入
Math.round(float a);
//a的b次幂
Math.pow(a,b);
//a的平方根
Math.sqrt(double a)
//a的立方根
    Math.cbrt(double a)
    //取一个[0.0,1.0)之间的随机数
    Math.random();

System

//停止程序
System.exit(0);
//显示时间(距1970年的毫秒)
System.currentTimeMillis();
//copy数组
System.arraycopy(数据源数组，起始索引，目的地索引，起始索引，拷贝个数)
int []  arry = new int[]{1,2,3};
int []  arry2 = new int[3];
//参数:1：据源数组，2：原数组第几个索引开始copy.3：拷贝到哪个数组，4：拷贝到目标数组的第几个索引，5：拷贝的长度
//4会覆盖原数组
System.arraycopy(arry,0,arry2,0,3);

Runtime

Runtime.getRuntime();

Data

//创建对象，指定一个时间,0L是0毫秒，是距离1970年0毫秒
Date date = new Date(0L);
//打印时间
System.out.println(date);//Thu Jan 01 08:00:00 CST 1970
//修改时间
date.setTime(1000L);
System.out.println(date);//Thu Jan 01 08:00:01 CST 1970
//获得距离1970年距离的毫秒数
long time = date.getTime();
System.out.println(time);//1000

SimpleDateFormat

1.日期对象—>字符串

public final String format(Date date)

//默认无参SimpleDateFormat
SimpleDateFormat simpleDateFormat = new SimpleDateFormat();
Date date = new Date();
String format = simpleDateFormat.format(date);
System.out.println(format);//22-9-16 下午1:10

//有参
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EE");
Date date = new Date();
String format = simpleDateFormat.format(date);
System.out.println(format);//2022年09月16日 13:17:03 星期五

2.字符串—>日期对象

public Date parse (String source)

String str = "2022-9-16 13:19:18";
//创建的对象要与字符串格式相同
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Date parse = simpleDateFormat.parse(str);
    System.out.println(parse);

//转换初恋的出生日期
    String str = "2000-11-11";
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
    Date parse = simpleDateFormat.parse(str);
    SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy年MM月dd日");
    String format = simpleDateFormat1.format(parse);
    System.out.println(format);
//秒杀活动
    Scanner scanner = new Scanner(System.in);
    SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
    System.out.print("在10秒内秒杀,输入1确认秒杀:");
    long l = System.currentTimeMillis();
    Date date = new Date(l);
    String next = scanner.next();
    long l1 = System.currentTimeMillis();
    String format = simpleDateFormat.format(date);
    if ((l+10000)>l1){
        System.out.println("秒杀成功");
    }else {
        System.out.println("秒杀失败");
    }
    System.out.println("您的秒杀时间为"+format);

Calendar

​ Calendar代表了系统当前的时间的日历对象，可以单独修改、获取时间中的年、月、日

​ 细节：Calendar是一个抽象类，不能直接创建对象

public static Calendar getInstance(); 		//获取当前时间的日期对象
public final Date getTime();  		  		//获取日期对象
public final setTime(Date date) 	  		//给日期设置日期对象
public long getTimeInMillis()		  		//拿到毫秒值
public void setTimeInmillis(long millis)	//给日历设置时间毫秒值
public int get(int field)					//获取日期中的某个字段信息
public void set(int field,int value)		//修改日期中的某个字段信息
public void add(int field,int amount)		//为某个字段添加减少指定的值

    Calendar instance = Calendar.getInstance();//获取当前时间的日期对象
	Date time = instance.getTime();//获取日期对象
	System.out.println(new SimpleDateFormat("yyyy年MM月dd日").format(time));

Arrays

Arrays.sort(shuzu);
Arrays.

SimpleDateFormat simpleDateFormat = new SimpleDateFormat(“yyyy年MM月dd日 HH:mm:ss”);
System.out.print(“在10秒内秒杀,输入1确认秒杀:”);
long l = System.currentTimeMillis();
Date date = new Date(l);
String next = scanner.next();
long l1 = System.currentTimeMillis();
String format = simpleDateFormat.format(date);
if ((l+10000)>l1){
System.out.println(“秒杀成功”);
}else {
System.out.println(“秒杀失败”);
}
System.out.println(“您的秒杀时间为”+format);


### Calendar

​	Calendar代表了系统当前的时间的日历对象，可以单独修改、获取时间中的年、月、日

​	细节：Calendar是一个抽象类，不能直接创建对象

```java
public static Calendar getInstance(); 		//获取当前时间的日期对象
public final Date getTime();  		  		//获取日期对象
public final setTime(Date date) 	  		//给日期设置日期对象
public long getTimeInMillis()		  		//拿到毫秒值
public void setTimeInmillis(long millis)	//给日历设置时间毫秒值
public int get(int field)					//获取日期中的某个字段信息
public void set(int field,int value)		//修改日期中的某个字段信息
public void add(int field,int amount)		//为某个字段添加减少指定的值

    Calendar instance = Calendar.getInstance();//获取当前时间的日期对象
	Date time = instance.getTime();//获取日期对象
	System.out.println(new SimpleDateFormat("yyyy年MM月dd日").format(time));

Arrays

Arrays.sort(shuzu);

大春老师
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Electron 实现窗口置顶效果
u011575498的博客
05-25 8371
Electron 实现窗口显示时置顶功能
java 窗口置顶_JAVA如何让窗体置于所有应用前面？
weixin_39672396的博客
02-12 3466
展开全部可以使用setAlwaysOnTop(true);实现置顶。可以实现只能最小化，不能缩放，通过代码setResizable(false);//禁止缩32313133353236313431303231363533e58685e5aeb931333363373130放来实现JOptionPane消息提示框的，如果在窗口置顶的情况下，还能弹出来看到，那么就需要设置一个参数，来指定他弹出的父组件...
Electron第三篇--基础功能实现
1024创新实验室
06-27 915
前言 前面我们一起了解了什么是Electron，了解了如何进行进程通信。 想要了解的可以点击移步第一篇 《教你一键开发桌面应用程序》与第二篇《Electron第二篇–进程通信》 接下来，让我们干点儿PC桌面应用程序该干的事儿。窗口操作、托盘设置、防应用多开等等…Electron提供了完整的方法，让我们只需要简单的设置即可轻松实现 窗口操作 Electron提供了一套默认的窗口以及工具栏，如下图 这可能不是我们想要的。我们有UI图，我们想要定制化窗口工具栏。这里就需要在创建浏览器窗口的时候给与参数设置为无边框
java如何调windows框_java – JDialog.setAlwaysOnTop(true)将所有对话框带到Windows下的前面...
weixin_39932692的博客
03-08 520
我创建了两个对话框：DialogA：setVisible(true)只调用一次.DialogB：setVisible(true)和setAlwaysOnTop(true)每1.5秒调用一次Windows：每次调用dialogB.setAlwaysOnTop(true)都会将dialogA和dialogB带到前面.OSX：每次调用dialogB.setAlwaysOnTop(true)只会将dial...
java基础笔记
04-11
Java 基础笔记 Java 是一种广泛使用的高级编程语言，它由 Sun Microsystems 公司开发，现归属 Oracle 公司所有。Java 语言是一种面向对象的编程语言，具有平台独立性、对象封装、继承和多态等特征。下面是 Java ...
尚硅谷JAVA基础笔记吐血整理
02-03
“尚硅谷JAVA基础笔记”涵盖了Java语言的基础知识，包括语言概述、基本语法、面向对象概念、封装、继承和多态，以及一些关键概念如形参与实参、属性与局部变量、构造器、this关键字、包和MVC设计模式的使用。...
Java基础笔记.pdf
11-30
Java 基础笔记 Java 是一种高级程序设计语言，应用广泛。本笔记将从基本概念开始，详细讲解 Java 的基础知识。 搭建环境和编译运行 在 Java 中，编译和运行程序需要搭建环境。首先，需要编写 Java 源代码，例如：...
java 显示顶层提示窗口
technologyleader的专栏
01-18 621
不显示顶层时的用法： JOptionPane.showMessageDialog(null,"普通提示窗口演示", "提示", 2); 顶层窗口用法： Frame frame = new Frame(); frame.setAlwaysOnTop(true);//设置顶层显示 JOptionPane.showMessageDialog((Component)frame,"顶层窗口演示", "提示", 2); ...
DAY09_继承&拼图游戏案例
m0_57075290的博客
02-20 106
继承，拼图游戏案例
将图形窗口设置为始终在顶部。：更改始终在顶部的窗口状态。-matlab开发
06-01
SETALWAYSONTOP(HFIG,TRUE) 将使带有句柄 HFIG 的 Matlab 图形位于操作系统中的其他窗口之上，即使它可能不在焦点上。 SETALWAYSONTOP(HFIG,FALSE) 将把图形恢复到正常的窗口状态。 SETALWAYSONTOP(HFIG) 与 SETALWAYSONTOP(HFIG,TRUE) 相同。 第二个布尔参数 TRUE/FALSE 也可以交换为数字 1/0。 限制： HFIG 必须具有属性值：Visible = on。 HFIG 必须具有属性值：WindowStyle = normal。 Swing 组件必须在当前的 Matlab 会话中可用。 例子： hFig = 图； setAlwaysOnTop(hFig,true); % 数字现在位于其他窗口的顶部
Java的JFrame窗体的创建(两种方法)
weixin_68658847的博客
11-28 8639
Java的JFrame窗体的创建(两种方法)
(个人笔记)java Swing 笔记
Mchange的专栏
04-20 879
显示窗体： JFrame.setVisible(true); 退出系统： System.exit(0); 全屏显示： this.setExtendedState(JFrame.MAXIMIZED_BOTH); //最大化         this.setAlwaysOnTop(true);    //总在最前面         this.setResizable(false);
java top.dialog控件,java – 如何只为他的父级创建JDialog onTop？
weixin_28848833的博客
03-11 226
可以说,我们有几个JFrame窗口同时可见,并且每个窗口都出现JDialog.当我们的窗口处于级联模式和对话框setAlwaysOnTop为真时,所有对话框将在最后一个窗口中可见.我只想将Dialog组件与其所有者关联起来,这样当你在Frames之间切换时,你只会在顶部获得一个对话框,并且在单击一个框架时不会丢失该对话框.对话框有这样的构造函数：setAlwaysOnTop(true);setMo...
JFrame显示层次问题
陈刚编程心得与知识集
04-06 812
有3个JFrame窗体A、B、C，如何实现B、C窗体始终在A前端，不要使用setAlwaysOnTop(true)方法。 setAlwaysOnTop(true)方法设置窗体显示在最前端会有很多后遗症。
javafx 窗口始终悬浮
rockllee的博客
08-03 4235
给Stage设置AlwaysOnTop属性就可以了。Stage stage =new Stage(); stage.setAlwaysOnTop(true);就可以啦
Java：始终在桌面最顶层显示窗体
Neither
05-21 7791
1.实现过程 (1).在项目中新建窗体类AlwaysActiveWindows，在窗体上添加标签控件。 (2).编写窗体界面设计代码，设置窗体标题即添加内容面板与标签控件。关键代码如下： import javax.swing.*; import java.awt.*; import java.awt.event.*; public class AlwaysActiveWindo
JAVA桌面宠物
qq_45956850的博客
01-19 6749
忄辰桌面宠物【静态】 最近寒假刚刚开始，然后时间很多，就想做一款桌面宠物，但是本人能力有限，只能做个静态的，其实我觉得静态也挺好看的是吧QAQ，想做动态的话可以参考链接2，用线程就可以实现了 感谢大佬的这两片文章: 连接1.连接2 第一步 我们需要有一个背景透明化的图片，我是用PS的，也是第一次用，如果大佬有更好的办法可以帮助一下我。。。 首先我们需要准备一张图片 比如进击的巨人 （三笠）百度找的图 然后打开我们的PS应用，打开这张图片 选择这个魔法棒，点击空白处键盘上的delete 效果如下 然后我
java基础笔记md
最新发布
06-15
# Java基础笔记 ## 1. Java简介 - Java语言特点: 平台无关性、垃圾回收机制 - JVM: 负责执行Java字节码 ## 2. 数据类型 - int, double, String等基本类型 - ```java // 声明并初始化一个整型变量 int num = 10; ``...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值