[java]——基础语法

最新推荐文章于 2026-05-04 10:00:00 发布
原创 最新推荐文章于 2026-05-04 10:00:00 发布 · 523 阅读 · 2 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
java之家

当前文章被收录于：

java之家
11 篇文章 1 人学习

刷刷刷

订阅专栏 查看详情

目录

前言

https://www.bilibili.com/video/BV18J411W7cE?p=107

打印

System.out.println() \\ 换行
System.out.print() \\不换行

注释

单行注释

//

多行注释

/* */

文档注释

/** */ 暂不用

常量

在这里插入图片描述
null无法使用System.out.println(null)输出

数据类型

七个数值型

在这里插入图片描述
整数默认是int，浮点数默认是double

类型转换

自动类型转换

小范围->大范围
在这里插入图片描述

强制类型转换

大范围->小范围
小范围数据类型 变量名 = (小范围数据类型) 大范围的数据
example:
int k = (int)88.88

变量

变量的定义格式

数据类型 变量名 = 变量值
example:
int a = 10;
long a = 1000000000**L**,如果没有L，右边默认为int
float a = 13.14F

命名约定

方法、变量

firstName

类

FirstName

运算符

算术运算符

在这里插入图片描述

字符的加操作

int i = 10;
char c = 'A';
System.out.println(i + c); // 这里的'A'变成65

int k = 10 + 13.14; // 报错:因为右边会进行数据类型的升级，即结果的数据类型是double~

字符串的加操作

即连接操作

赋值运算符

short s = 10;
s += 20; // 隐含了强制类型转换，也就是说，右边强制转换成short

s = s + 20; // 报错:因为右边会进行数据类型的升级，即结果的数据类型是short~

自增自减运算符

int i = 10;
int j = i++; // j=i先执行，j=10
int j = ++i; // ++i先执行，j=11

逻辑运算符

在这里插入图片描述
1<a<2需要写成 (1<a) & (a<2)

短路

&&: 左边为False，右边不执行
||:左边为True，右边不执行

三元运算符

a>b?a:b
Example:

public class HelloWorld2 {
	public static void main(String[] args){
		int a1 = 100;
		int a2 = 200;
		int a3 = 300;
		int tmp_a = a1>a2?a1:a2;
		int max_a = tmp_a>a3?tmp_a:a3;
		System.out.println("max_a:"+max_a);
	}
}

数据输入——Scanner

Example:

import java.util.Scanner;
public class HelloWorld2{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		System.out.println("a:"+a);
	}
}

分支语句

if

if(条件语句){
	执行语句;
}

if(条件语句){
	执行语句1;
}else{
	执行语句2;
}

if(条件语句){
	执行语句1;
}else if(条件语句){
	执行语句2;
}else if(条件语句){
	执行语句3;
}else{
	执行语句4;
}

switch

switch需要先计算表达式的值，然后和case中的值进行配对。

switch(表达式){
	case 值1:
		执行语句1;
		break;
	case 值2:
		执行语句2;
		break;
	case 值3:
		执行语句3;
		break;
	case 值4:
		执行语句4;
		break;
	default:
		执行语句5;
		break; // break可以省略
}

Example:case 穿透

import java.util.Scanner;

public class HelloWorld2{
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int month = sc.nextInt();
		switch(month) {
			case 1:
			case 2:
			case 12:
				System.out.println("冬季");
				break;
			case 3:
			case 4:
			case 5:
				System.out.println("春季");
				break;
			case 6:
			case 7:
			case 8:
				System.out.println("夏季");
				break;
			case 9:
			case 10:
			case 11:		
				System.out.println("秋季");
				break;
			default:
				System.out.println("错");
		}
	}
}

for

for(初始化语句;条件判断语句;条件控制语句){
	循环体语句;
}

初始化语句中的变量只属于for循环内部

while

初始化语句;
while(条件判断语句){
	循环体语句;
	条件控制语句;
}

do…while

初始化语句
do{
	循环体语句'
	条件控制语句;
}while(条件判断语句);

Example:先执行do

public class HelloWorld2{
	public static void main(String[] args){
	int j = 1;
	do{
		System.out.println("j:"+j);
		j++;
	}while(j<=0);
	}
}

死循环

for(;;){}
while(True){}
do{}while{True}

random

import java.util.Random;

public class HelloWorld2{
	public static void main(String[] args){
		Random r = new Random();
		int a = r.nextInt(100) + 1; // (0-99)   + 1
		System.out.println("a: "+a);
	}
}

数组

数组定义格式

int[] arr // √
int arr[] // ×

数组动态初始化

int[] arr = new int[3];

**默认的值为0**

数组元素访问

arr[i]

多个数组指向相同的内存空间

int[] arr2 = arr1;

数组静态初始化

int[] arr = new int[]{...}
int[] arr = {...}

数组遍历

int[] arr = {1,2,3};
for(int i=0;i<arr.length;i++){
    System.out.println(arr[i]);
}
👇
for (int j : arr) {
    System.out.println(j);
}

char[] arr = {'1','2','3'};
for (char c : arr) {
    System.out.println(c);
}

最值

用遍历

方法

方法的定义和调用

定义

public static void 方法名() {
	//方法体
}

调用

psvm{
	方法名()
}

带参数的方法

定义

public static void 方法名(数据类型 变量名){
	...
}

调用

psvm{
	方法名(参数)
}

带返回值的方法

public class ...{
	public static void main(){
		boolean res = fuc();
	}
	public static boolean fuc(){
		...
	}
}

方法重载

在这里插入图片描述
在这里插入图片描述
Example:
在这里插入图片描述

public static int sum(int a, int b){
    return a+b;
}
public static double sum(double a, double b){
    return a+b;
}
public static int sum(int a, int b, int c){
    return a+b+c;
}

方法的参数传递

基本参数

不改变~

引用参数

改变:

public static void main(String[] args) {
    int[] arr = {10,20,30};
    System.out.println(arr[1]);
    change(arr);
    System.out.println(arr[1]);
}
public static void change(int[] arr){
    arr[1] = 300;
}

例子

反转

public static void reverse(int[] arr){
    int tmp = 0;
    for (int start=0,end=arr.length-1; start <= end;start++, end--){
        tmp = arr[start];
        arr[start] = arr[end];
        arr[end] = tmp;
    }
}

Debug

删除多个断点在这里插入图片描述

类和对象

类

public class Phone {
    String brand; //成员变量
    int price;
    public void call(){ //成员方法 没有static
        int i = 0; // 局部变量
        System.out.println("打电话");
    }
    public void sendMessage(){
        System.out.println("发短信");
    }
}

对象

Phone p = new Phone();

面向对象之封装

如果一个成员变量被private修饰了，那么只能在本类中被访问，所以可以在本类中向外部提供访问(get)和修改(set)的接口方法。

private String name;
private int age;
public void setName(String name){
    this.name = name;
}
public String getName(){
    return name;
}
public void setAge(int a){
    if(a>0){
        age = a;
    }else{
        System.out.println("错误");
    }
}
public int getAge(){
    return age;
}

this

public class ...{
	String name;
	public void setName(String name){
		name = name; // 此时name为null，即成员变量name并没有被设置，因为这里的name都是局部变量。
	}
}
👇

public class ...{
	String name;
	public void setName(String name){
		this.name = name; // 此时name为null，即成员变量name并没有被设置，因为这里的name都是局部变量。
	}
}

构造方法

当一个类中没有自己定义构造方法，在main方法中，对其进行实例化时，系统会给定一个默认的无参数构造方法
带参数的构造方法需要我们自己定义，一旦定义，系统默认的无参数构造方法就会失效，如果我们依然要使用无参数构造方法，那么也需要自己重新定义之。

字符串

字符串的定义

在这里插入图片描述

String s1 = new String(); // 一个new，就会有一个新的对象
System.out.println(s1);

char[] chs = {'a','b','c'};
String s2 = new String(chs);
System.out.println(s2);

byte[] bys = {97, 98, 99};
String s3 = new String(bys);
System.out.println(s3);

String s4 = "abc";  // 如果String s5 也= "abc"，则 s5和s4在同一个地址
System.out.println(s4);

字符串的比较——equals

==

  • 基本类型：比较的是数据值
  • 引用类型：比较的是地址值 --如果要比较引用类型的数据值–>equals
s1.equals(s2)

字符串的遍历——charAt

for(int i=0;i<s.length();i++){
	sout(s.charAt(i));
}

判断大小写\数字字符

大写:
ch>='A' && ch <='Z'
小写:
ch>='a' && ch <='z'
数字
ch>='0'&&ch<='9'

StringBuilder

定义

在这里插入图片描述

添加(append)和反转(reverse)方法

添加

StringBuilder sb = new StringBuilder("xsy");
sb.append("hello").append("10");  // 由于sb.append()返回的是对象本身，所以支持链式编程
System.out.println(sb);

反转

sb.reverse();

StringBuilder ->String 的转化(toString)

StringBuilder sb = new StringBuilder();
String s = sb.toString();

String ->StringBuilder 的转化(构造方法)

StringBuilder sb2 = new StringBuilder(s);

集合(ArrayList)

定义

import java.util.ArrayList;
ArrayList<String> array = new ArrayList<>()

添加元素(add)

末尾添加

array.add(...);

指定位置添加

array.add(index, elements);

删除(remove)

array.remove(elements);
array.remove(index);

修改(set)

array.set(idnex,elements);

获取(get)

array.get(index);

长度(size)

array.size()

继承

定义

public class child extends parent{
	...
}

子类对于父类的访问

子类如果要访问父类的成员变量，该方法不能是private修饰的变量
子类的成员方法中定义了同名的局部变量，此时，如果要访问子类的成员变量，需要加this. 而如果要访问父类的成员变量，需要加super
子类创建对象时，首先要使用父类的无参构造方法

如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？

方法一：在子类的构造方法中，使用super显式使用父类的带参构造方法

public class parent {
    public int age = 10;
    public parent(int age){
        this.age = age;
    }
}
public class child extends parent{
    private int age;
    public child(int age){
        super(age);
        this.age = age;
    }
}

方法二：在父类中定义无参构造方法

public parent(){
}

方法重写

public class parent {
    public int age;
    public void show(){
        System.out.println(age);
    }
}
public class child extends parent{
    private int age;
    @Overide//可以帮助检查重写方法的正确性
    public void show(){
        super.show();
        System.out.println("other");
    }
}

在这里插入图片描述

自动建包

有一个程序，属于1.2这个二级包:

package 1.2;
public class HelloWorld{
	public static void main{
		....
	}
}

编译:自动创建1.2这个二级目录，并在其中生成HelloWorld.class
java -d . HelloWorld.java
运行:
java 1.2. HelloWorld.java

修饰符

权限修饰符

四种权限

package lesson1;

public class parent {
    void show1(){} // 3
    public void show2(){} // 1
    protected void show3(){}  // 2
    private void show4(){} // 4
}

相同包下的子类

除了private
在这里插入图片描述

相同包下的无关类

在这里插入图片描述

不同包下的子类

在这里插入图片描述

不同包下的无关类

在这里插入图片描述

总结

在这里插入图片描述

状态修饰符——final

final的定义与作用

final修饰成员方法:该类中的该方法是最终方法，不可以被任何子类重写

    public final void method(){
        System.out.println("1");
    }

final修饰成员变量:该变量不能被改变

public final int age = 20;

final修饰类:该类不能作为父类

public final class parent {}

final修饰基本类型变量:变量不能被修改

final int age = 20;

final修饰引用类型变量:引用类型变量的值可以被修改，地址不能被修改

final Student s = new Student();
s.age = 20; // √
s = new Student(); // ×

状态修饰符——static

定义

static修饰成员变量:被所有对象共享，只需要通过类名初始化一次

public class Student {
    public static int age = 20; 
}
----
public class other{
	public static void main(){
		Student.age = 20; // 建议直接使用类名进行初始化
	}
}

static修饰成员方法:非静态的成员方法可以访问静态、非静态方法；静态、非静态变量 |||| 静态成员方法只能访问静态方法；静态变量

public class Student {
    public static int age = 20;
    public int age2 = 30;

    public void show1(){}
    public static void show2(){}

    public void test(){
        System.out.println(age);
        System.out.println(age2);
        show1();
        show2();
    }
    public static void test2(){
        System.out.println(age);
        show2();
    }
}

多态

多态的定义

向上转型

Animal a = new Cat(); // Animal是父类，Cat是子类

向下转型

Cat c = (Cat)a;

如果a是Dog(Dog也是Animal的子类，则无法向下转型成Cat)

多态的访问

成员变量:
即：

  • 只能使用父类的成员变量，如果子类也有此成员变量，值也应该是父类的
  • 只能使用父类的成员方法，如果子类也有此成员方法，将进行复写，值应该是子类的

多态的使用

动物类：eat

猫类:eat、狗类:eat、猪类:eat

使用动物类

public void useAnimal(Animal a){
	a.eat();
}

在main中，只需要创建猫、狗、猪的对象，把对象传入给使用动物类的useAnimal方法，就可以使用猫、狗、猪这些动物的子类的方法了。但是只能使用这些子类中，在父类也定义过的方法，就比如eat，而a.drink是不行的，除非动物类也有drink这个方法。

多态的转型

向上转型

向下转型

抽象类

抽象类的定义

public abstract class Animal {
    public int age;
    public abstract void eat();
}

抽象类的性质

  • 抽象类无法被实例化，除非通过多态(向上转型)
  • 抽象类的子类要么重写抽象类的所有抽象方法，要么子类也是抽象类

接口

接口的定义

public interface Jumping {
    public abstract void jump();
}

接口的使用(实现类)

public class Cat implements Jumping{
    @Override
    public void jump() {
        System.out.println("haha");
    }
}

接口的特点

成员特点

  • 成员变量:都是被 static和final修饰了的(public static final)
  • 构造方法:不能定义构造方法（那么子类的初始化时，会先去调用接口的无参构造方法，怎么办呢?——object是所有类的超类）
  • 成员方法:只能是抽象方法(public abstract)

接口与类:类可以多实现接口:

public class Cat extends Object implements Jumping,Jumping1{

接口与接口:接口可以多继承接口

public interface Jumping3 extends Jumping,Jumping1{
}

接口和抽象类的区别

包括行为和属性，总体还是要继承抽象类的。如果新增了某些行为，那么定义成接口去实现。
在这里插入图片描述

内部类

内部类和外部类的关系

  • 内部类可以访问外部类
  • 外部类只能访问内部类的对象

内部类的分类与定义

成员内部类
局部内部类
匿名内部类

成员内部类

成员内部类的定义

package lesson7;

public class Outer {
    int num = 10;
    public class Inner{
        int a = 10;
        public void show(){
            System.out.println(num);
        }
    }
    public void method(){
        Inner i = new Inner();
        i.show();
        System.out.println(i.a);
    }
}

创建成员内部类的对象

外部类名.内部类名 对象名=外部类对象.内部类对象
example:
Outer.Inner oi = new Outer().new Inner()

成员内部类的一般使用方法(private)

public class Outer {
    int num = 10;
    private class Inner2{
        public void show(){
            System.out.println(num);
        }
    }
    public void method(){
        Inner2 i = new Inner2();
        i.show();
    }
}
//通过外部类的method去访问内部类

局部内部类

局部内部类的定义

public class Outer {
    int num = 10;
    public void method2(){
        int num2 = 20;
        class Inner3{
            public void show(){
                System.out.println(num);
                System.out.println(num2);
            }
        }
        Inner3 i = new Inner3();
        i.show();
    }
}

匿名内部类

局部内部类的特殊形式，其实是一个继承父类或者实现接口的一个对象！

匿名内部类的定义

定义一个接口:

public interface Inter {
    void show();
}

创建匿名内部类

public class Outer {
    int num = 10;
    public void method(){
        new Inter(){
            @Override
            public void show() {
                System.out.println("haha");
            }
        }.show(); // 对象直接调用方法
    }
}

由于是对象，则直接可以赋值给变量(顶级理解👇)

public class Outer {
    int num = 10;
    public void method(){
        Inter i = new Inter(){
            @Override
            public int show() {
                return 0;
            }
        }; //
        int j = new Inter(){
            @Override
            public int show() {
                return 1;
            }
        }.show();
        System.out.println(i.show());
        System.out.println(j);
    }
}

匿名内部类的使用

定义一个接口

public interface Jumping {
    void jump();
}

定义一个普通类，类中的方法的参数是：实现接口的类的对象

public class JumpingOperator {
    public void method(Jumping j){
        j.jump();
    }
}

使用该method

//1：
JumpingOperator jo = new JumpingOperator();
        Jumping j = new Cat();
        jo.method(j);
//2：使用匿名内部类直接创建对象
jo.method(new Jumping() {
    @Override
    public void jump() {
        System.out.println("hahaha");
    }
});

常用的API

Math

在这里插入图片描述

System

在这里插入图片描述

Object

在这里插入图片描述

toString()

Student s = new Student();
System.out.println(s.toString()); // 由于object是所有类的父类，所以Student也有toString方法，建议重写👇

@Override
public String toString() {
    return "Student{" +
            "aga=" + aga +
            ", name='" + name + '\'' +
            '}';
}

equals

重写equals

@Override
public boolean equals(Object o) {
    if (this == o) return true;
    if (o == null || getClass() != o.getClass()) return false;

    Student student = (Student) o;

    if (aga != student.aga) return false;
    return name != null ? name.equals(student.name) : student.name == null;
}

Arrays

在这里插入图片描述
example:

int[] arr = {24, 69, 80, 57, 13};
System.out.println(Arrays.toString(arr));
Arrays.sort(arr);
System.out.println(Arrays.toString(arr));

基本类型包装类

在这里插入图片描述

Integer

最大值最小值

Integer.MAX_VALUE
MIN_VALUE

构造方法

加粗样式

Integer i1 = Integer.valueof(100)
Integer i1 = Integer.valueof("100") // 字符串-->Integer

String

Int和String的转换

int转换为String：

String s = String.valueOf(int);

String转换为int:

//1 String->Integer->int
Integer i = Integer.valueOf(String);
int ii = i.intValue();
//2 String -> int
int i = Integer.parseInt(String)

以空格为分割符的String转换成int类型的数组

import java.util.Array;
String strArray = "1 2 3 4";
int[] intArray = new int[strArray.length];
for(int i = 0;i < strArray.length; i++){
	intArray[i] = Integer.parseInt(strArray[i]);
}
Arrays.sort(intArray);
String res = Arrays.toString(intArray);

自动装箱和拆箱

装:基本类型->包装类型

Integer i = Integer.valueOf(100);
Integer ii = 100; // 自动

拆:包装类型->基本类型

int iii = ii.intValue();
int iiii = ii; // 自动

日期类

在这里插入图片描述

Date

构造方法

Date d1 = new Date();
long a = 1000*60*60;
Date d2 = new Date(a);

获取时间(getTime())

设置时间(setTime())

SimpleDataFormat

在这里插入图片描述

定义

SimpleDateFormat sdf = new SimpleDateFormat()
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss")

格式化——format

传date，得String
在这里插入图片描述

Date d = new Date();
String = sdf.format(d);

public static String dateToString(Date data, String format){
SimpleDateFormat sdf = new SimpleDateFormat(format);
String s = sdf.format(data);
return s;
    }

解析——parse

在这里插入图片描述
传String，得date

String ss = "2021 02 17 09 27 20";
SimpleDateFormat sdf = new SimpleDateFormat("yyyy MM dd HH mm ss"); //需要跟ss对应
Date dd = sdf.parse(ss);
System.out.println(dd);

public static Date stringToDate(String s, String format) throws ParseException { // 系统提示使用parse时，可能出现字符串和format不匹配的编译异常，1. throws Par.... 2. try..catch...
SimpleDateFormat sdf = new SimpleDateFormat(format);
Date d = sdf.parse(s);
return d;
}

Calendar

定义

Calendar是一个抽象类

Calendar c = Calendar.getInstance();

日历字段

Calendar类中的静态成员变量
Calendar.YEAR

返回给定日历字段的值——get

int year = c.get(Calendar.YEAR);
int month = c.get(Calendar.MONTH) + 1; // 从0开始

修改日历字段——add&set

c.add(Calendar.YEAR, -1);

//直接设置
c.set(2048, 11, 11);

异常

在这里插入图片描述

异常处理

try…catch…

代码格式

在这里插入图片描述

try{
	代码;
}catch(ArrayIndexOutOfBoundsException e){
	代码;
}
异常类的常用成员方法

sout(e.getMessage())
sout(e.toString())
sout(e.printStackTrace())

throws

在这里插入图片描述

自定义异常

在这里插入图片描述

public class Teacher {
    public void checkScore(int score) throws ScoreException { // 调用该方法时，需要用try catch解决该异常，因为该异常继承自exception，是编译异常。
        if(score<0 || score > 100){
            throw new ScoreException();
        }else{
            System.out.println(score);
        }
    }
}

集合进阶

集合类的体系结构

在这里插入图片描述

collection

collection重写了toString的方法呦~

定义(ArrayList)

Collection<String> c = new ArrayList<String>();

常见方法

在这里插入图片描述

c.add();
c.remove(); // 删除前面的
c.clear();
c.contains();
c.isEmpty();
c.size();

遍历

得到collection的迭代器:

Iterator<String> it = c.iterator();

获取下一个元素:

it.next();

判断是否有下一个元素:

it.hasNext();

List

定义(ArrayList)

List<String> list = new ArrayList<String>();

常用方法:

在这里插入图片描述

list.add();
list.size();
//特有
list.add(index, elements);
list.remove(index);
list.set(index, elements);
list.get(index);

遍历:

通过get进行遍历

并发修改异常(checkForComodification)

使用iterator遍历集合list的过程中，对集合list添加、删除了元素：

while (it.hasNext()) {
            String s = it.next();
            list.add("nihao");
            System.out.println(s);
        }

对list进行for循环遍历就不会出错:

 for(int i = 0; i < list.size(); i++){
            String s = list.get(i);
            list.add("nihao");
            System.out.println(s);
        }

list集合的特有迭代器——listiterator()

常用方法:
在这里插入图片描述
使用listiterator遍历集合list的过程中，可以对集合list添加、删除元素。

增强for循环

for(String s:list){
	...
}

ArrayList(数组)&LinkedList(链表)

在这里插入图片描述
LinkedList:

LinkedList<String> linkedlist = new LinkedList<String>();
linkedlist.add("hello");
linkedlist.addFirst("hello");
linkedlist.addLast("hello"); // = add
linkedlist.getFirst("hello");
linkedlist.getLast("hello");
linkedlist.removeFirst("hello");
linkedlist.removeLast("hello"); // = remove

Set

集合中只能存储引用类型

定义(通过HashSet)

Set<String> set = new HashSet<String>();

哈希值

"string".hashCode();

HashSet

不可重复、无序

定义
HashSet<String> hs = new HashSet<String>();
案例:HashSet集合存储学生对象并遍历(重写对象类的hashCode和equals方法)

HashSet存储对象的原理:
在这里插入图片描述
所以两个成员变量相同的对象，i依然可以存储进同一个HashSet，如何解决？——重写对象类的hashCode和equals方法!

LinkedHashSet

由哈希表(不可重复)和链表(有序)实现

定义
LinkedHashSet<String> lsh = new LinkedHashSet<String>();

TreeSet

定义
TreeSet<Integer> ts = new TreeSet<Integer>();
自然排序（无参构造，实现Comparable接口）

使用无参构造方法
实现对自定义的学生类进行自然排序
现在的问题是:
在这里插入图片描述
所以，如果我们不对学生类实现自然排序，就会报错:

重写Comparable接口中ComparaTo的return值

0:
只能存储一个对象，因为0代表大小相同
1:
按照给定的存储顺序存储（升序）
-1:
按照给定的存储顺序逆序存储
自定义(单个成员变量):

public int compareTo(Student o) {
   return this.age - o.getAge(); // 升序，this代表当前元素
}

自定义(多个成员变量):

public int compareTo(Student o) {
   int num =  this.age - o.getAge(); //主要
   int num2 = num==0? //次要this.name.compareTo(o.name):num;
   return num2;
    }
非自然排序（比较器排序）（带参构造:Comparator对象）
TreeSet<Student> ts = new TreeSet<Student>(new Comparator<Student>() {
   @Override
   public int compare(Student o1, Student o2) {
       int num = o1.getAge() - o2.getAge();
       int num1 = num == 0?o1.getName().compareTo(o2.getName()):num;
       return num1;
   }
});

泛型

定义的格式

在这里插入图片描述

泛型类

泛型类下面的方法，不需要指定参数的类型，可以传入多种类型的参数

泛型类的定义
class Generic<T>{
    private T t;
    public T getT(){
        return t;
    }
    public void setT(T t){
        this.t = t;
}

泛型方法

现在有这样的类

class Generic<T>{
    public void show(T t) {
        System.out.println(t);
    }
}

如果要让show方法输出不同类型的值，就需要对象化不同类型的Generic类，这样太麻烦.

泛型方法的定义
class Generic{
    public <T> void show(T t) {
        System.out.println(t);
    }
}

泛型接口

public interface Generic<T> {
    void show(T t);
}

实现类

class GenericImlp<T> implements Generic<T>{
    public void show(T t){
        System.out.println(t);
    }
}

类型通配符

定义格式(?)
List<?> list1 = new ArrayList<Object>();
List<?> list2 = new ArrayList<Integer>();
上限(extends)
List<? extends Object> list3 = new ArrayList<Object>();
List<? extends Number> list4 = new ArrayList<Integer>();
下限(super)
List<? super Object> list5 = new ArrayList<Object>();
List<? super Integer> list6 = new ArrayList<Number>();

-----255

一些轮子

arrayToString

描述

把数组中的元素按照指定的规则组成一个字符串

代码

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

冒泡排序

描述

冒泡排序

代码

public class maopao {
    public static void main(String[] args) {
        int[] arr = {24, 69, 80, 57, 13};
        System.out.println("排序前:"+arrayToString(arr));
        for(int i=0;i<=arr.length-2;i++){
            for(int j=0;j<=arr.length-2-i;j++){
                if(arr[j] > arr[j+1]){
                    int temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        System.out.println("排序后:"+arrayToString(arr));
    }

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

不可重复的随机数

描述

获取10个1-20之间的随机数，随机数不能重复

public class SetDemo {
    public static void main(String[] args) {
        Random r = new Random();
        Set<Integer> s = new HashSet<Integer>();
        while(s.size() < 10){
            int i = r.nextInt(20) + 1;
            s.add(i);
        }
        System.out.println(s);
    }
}
《Linux运维总结：Ubuntu22.04忘记root密码解决方案》
东城绝神
02-20 4391
《Linux运维总结：Ubuntu22.04忘记root密码解决方案》
华为OD机试真题 新系统 2026-04-26 Python&JS 实现【最大化游戏试玩资格分发】
最新发布
MISAYAONE的博客
05-04 188
新研发了一台游戏设备可以面向用户接受试玩。现有 n 个试玩申请，每个试玩有开始时间和结束时间。作为协调员，为了能让更多人体验到游戏，你需要对试玩申请进行选择，使得：
Java基础语法
热门推荐
terence的博客
03-27 10万+
1. Java概述 1.1 Java语言发展史 语言:人与人交流沟通的表达方式 计算机语言:人与计算机之间进行信息交流沟通的一种特殊语言 Java语言是美国Sun公司(Stanford University Network)在1995年推出的计算机语言 Java之父:詹姆斯·高斯林(James Gosling) 2009年，Sun公司被甲骨文公司收购，所以我们现在访问oracle官网即可:https://www.oracle.com 当前，我们课程使用的JDK版本:11.0 1.2 Java语言跨平台原理
微信小程序-养生小程序
微信小程序-养生小程序
java基础语法
m0_46263270的博客
06-02 1038
Java基础的语法内容总结，从0到1学基础
[java]——对ArrayList集合中的元素(自定义类)进行排序
jokerxsy的博客
02-18 1271
前言 如果ArraylIst中存放的不是整型等基本类型，而存放的是自定义类这样的引用类型，我们应该如何对其进行排序呢？(emmm这玩意儿在python中edge_lst = sorted(edge_lst, key=lambda x: x.weight)一句话就解决了…吐血1今天找小姐姐说话，没发挥好，吐血2) 这里的排序使用的是Collections这个工具类的sort静态方法，也就是说不需要对Collections进行实例化，就可以使用。 方法一:自定义类实现Comparable接口，并重写compar
[java]——window64位下java的安装与配置
jokerxsy的博客
01-24 740
前言 为生活所迫而学java 下载JDK JAVA DEVELOPMENT KIT(JDK) = JAVA RUNTIME ENVIRONMENT(JRE) + JAVA工具+JAVA基础库类。——热心市民辜先生 官方网址https://www.oracle.com/cn/java/technologies/javase-downloads.html#JDK15 选择JAVA SE 8 下面的JDK Download 选择windows 64位的安装包 安装JDK 直接点下一步就可以了，记住你的安装
蓝桥杯刷题
jokerxsy的博客
02-17 553
前言 … 第十一届蓝桥杯大赛个人赛校内选拔（软件类）真题 1.15.125GB 15,488MB 2.约数个数 96 3.叶结点数 1010 4.数字9 544 5.数位递增的数 python def judge(num): tmp_max = 9 while(num): if num % 10 <= tmp_max: tmp_max = num % 10 num //= 10 else:
[java]——leetcode刷题(深度优先搜索)(简单21+中等25)
jokerxsy的博客
02-22 533
前言 简单题 1.最小高度数
[java]——leetcode刷题(动态规划)(简单8中等11)(TBC)
jokerxsy的博客
03-11 326
前言 妈的，深搜都刷不会. 简单 1. 1025. 除数博弈 题目描述: 爱丽丝和鲍勃一起玩游戏，他们轮流行动。爱丽丝先手开局。 最初，黑板上有一个数字 N 。在每个玩家的回合，玩家需要执行以下操作： 选出任一 x，满足 0 < x < N 且 N % x == 0 。 用 N - x 替换黑板上的数字 N 。 如果玩家无法执行这些操作，就会输掉游戏。 只有在爱丽丝在游戏中取得胜利时才返回 True，否则返回 False。假设两个玩家都以最佳状态参与游戏。 思路1:数学 当N=1时，输 当N
[java]——数据结构基础
jokerxsy的博客
03-06 315
前言 听丰哥的，先利用每天的一小时，把菜鸟教程过一遍~ 道阻且长~ java数据结构概述 Java Stack 类 Stack<Integer> st = new Stack<Integer>(); st.push(new Integer(1)); // 把项压入堆栈顶部。 Integer a = st.peek(); // 查看堆栈顶部的对象，但不从堆栈中移除它。 int place = st.search(1); // 从栈顶往下搜索，返回对象在堆栈中的位置，以 1 为基数。 I
[java]——leetcode刷题(深度优先搜索)(中等??)(TBC)
jokerxsy的博客
03-01 302
前言 我又回来啦~ 26.526. 优美的排列 题目描述: 假设有从 1 到 N 的 N 个整数，如果从这 N 个数字中成功构造出一个数组，使得数组的第 i 位 (1 <= i <= N) 满足如下两个条件中的一个，我们就称这个数组为一个优美的排列。条件： 第 i 位的数字能被 i 整除 i 能被第 i 位上的数字整除 现在给定一个整数 N，请问可以构造多少个优美的排列？ ...
[java]——int和char类型的转换
jokerxsy的博客
03-01 294
前言 做529. 扫雷游戏发现卡在这儿了 int转换成char int i = 9; char c = (char)(i+'0') char转换成int char c = 'a'; int i = c - '0'; 参考 【Java】 int与char类型间的相互转化
[java]——IntelliJ IDEA安装与基本操作
jokerxsy的博客
02-15 221
前言 notepad看来不够香 步骤 下载:https://www.jetbrains.com/idea/ 安装: 配置 创建一个空项目: 创建一个新模块: 新建包 新建类 Helloworld 右键->run~
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值