java 多个类的方法实现抽象方法指定一个

转载

落笔成诗 2024-10-14 10:06:48

文章标签 可以有多少个简单java类呢 System 字符串 ci 文章分类 Java 后端开发

Random

Random类用来创建一个新的随机数生成器。

对象数组

ArrayList集合的长度是可以随意改变的。

ArrayList这个代表泛型

泛型：装在集合当中的所有元素，全部都是统一的类型。泛型只能是引用类型，不能使用基本元素。

import java.util.ArrayList;
public class ArrayListExercise {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
list.add("盖伦");
list.add("锐雯");
list.add("亚索");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
}
}
boolean add(E e)
E get(int index)
E remove(int index)
int size()
ArrayList集合中存储基本数据类型时，必须使用基本数据类型对应的包装类。
基本类型
包装类
byte
Byte
short
Short
int
Integer
long
Long
double
Double
char
Character
boolean
Boolean
字符串
Java程序中的所有的字符串字面值(“ABC”)都作为此类的实例实现。
字符串效果上相当于是char[]字符数组，但是底层原理是byte[]字节数组。
字符串的构造方法和直接创建
public class StringExercise {
public static void main(String[] args) {
//使用空参构造
String string1 = new String();
System.out.println(string1);
//使用字符数组构造
char[] chars = {'A','B','C'};
String string2 = new String(chars);
System.out.println(string2);
//使用字节数组构造
byte[] bytes = {97,98,99};
String string3 = new String(bytes);
System.out.println(string3);
//直接创建
String string4 = "hello";
System.out.println(string4);
}
}
字符串常量池
程序当中直接写上的双引号字符串，就在字符串常量池中。
倒叙遍历
import java.util.Arrays;
public class ArraysExercise {
public static void main(String[] args) {
String string = "abdsdafawaswa";
char[] chars = string.toCharArray();
Arrays.sort(chars);
//chars.fori快捷
for (int i = 0; i < chars.length; i++) {
System.out.println(chars[i]);
}
//chars.forr快捷
for (int i = chars.length - 1; i >= 0; i--) {
System.out.println(chars[i]);
}
}
}
改写Object类中的toString和equals方法
import java.util.Objects;
public class Person {
private String name;
private int age;
@Override
public String toString() {
//对toString方法进行重写，使可以输出自己想要输出的内容，而不再输出对应对象的地址
return "Person{" + "name:" + name + ",age:" + age + "}";
}
/*
Object类的equals方法，默认比较的是两个对象的地址值，没有意义
可以进行重写，比较的内容自己设置
问题：
1、隐含一个多态
2、多态的弊端：无法使用子类特有的内容(属性和方法)
解决：可以使用向下转型把obj类型转换为自己定义的类型
*/
// @Override
 public boolean equals(Object obj) {
 if(obj == this){
 return true;
 }
 if(obj == null){
 return false;
 }
 //向下转型
 if(obj instanceof Person){
 Person person = (Person)obj;
 //比较两个对象的属性，一个为this，一个为转换的对象。
 return this.name.equals(person.name) && this.age == person.age;
 }
 return false;//不是对应的类型，直接返回false
 }
@Override
public boolean equals(Object o){
if(this == o) return true;
//getClass() != o.getClass()使用反射技术，判断o是否是Person类型，
//等效于obj instanceof Person
if(o == null || getClass() != o.getClass()) return false;
Person person = (Person)o;
return age == person.age && Objects.equals(name,person.name);
//Objects.equals()方法会放在空指针异常(null)
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
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 class ObjExercise {
public static void main(String[] args) {
Person person1 = new Person("sunwu",20);
Person person2 = new Person("huayue",22);
System.out.println(person1);
System.out.println(person2);
boolean bool = person1.equals(person2);
System.out.println(bool);
}
}
Data类
import java.util.Date;
public class DateExercise {
public static void main(String[] args) {
System.out.println(System.currentTimeMillis());
demoOne();
demoTwo();
demeThree();
}
private static void demeThree() {
Date data = new Date();
System.out.println(data.getTime());
}
public static void demoOne(){
Date date = new Date();
System.out.println(date);
}
public static void demoTwo(){
Date date = new Date(1583560500337L);
System.out.println(date);
}
}
DateFormat(抽象类)
格式化(日期-->文本)、解析(文本-->日期)
SimpleDateFormat类
构造方法：
SimpleDateFormat(String pattern)用给定的模式和默认环境的日期格式符号构造SimpleDateFormat
参数pattern：传递指定的模式
y年M月d日H时m分s秒
写对应的模式，会把模式替换为对应的日期和时间
"yyyy--MM-dd HH:mm:ss"，连接发符号可以改变
format(Date date)按照指定的模式，吧Date日期格式化为符号模式的字符串
parse(String source)把符号模式的字符串解析为date日期
parse声明了一个异常parseException，如果字符串和构造方法的模式不一样，那么程序就会抛出异常。这里采用不处理只声明异常的方法 throws ParseException
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatExercise {
public static void main(String[] args) throws ParseException {
//demoOne();
demoTwo();
}
private static void demoTwo() throws ParseException {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy--MM--dd HH:mm:ss" );
Date date = simpleDateFormat.parse("2020--03--07 23:07:52");
System.out.println(date);
//如果解析的字符串与格式不一样，就会抛出异常。
}
private static void demoOne(){
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy--MM--dd HH:mm:ss" );
Date date = new Date();
String dateFormat = simpleDateFormat.format(date);
System.out.println(date);
System.out.println(dateFormat);
}
}
Calendar类：日历类(是一个抽象类)，里面有很多操作日历字段的方法
Calendar类无法直接创建对象，里面有一个静态方法叫getInstance()，该方法返回了Calendarr类的子类对象。
常用的成员方法
1、 pubilc int get(int field)：返回给定日历字段的值
2、 pubilc void set(int field ,int value):将给定的日历字段设置为给定值
3、 public abstract void add(int field, int amout):根据日历的规则，为给定的日历字段添加或减去指定的时间量
4、 pubilc Date getTime():返回一个表示此Calendar时间值的Date对象
int field:日历类的字段，可以使用Calendar类的静态变量获取
YEAR = 1 年
MONTH = 2 月
DATE = 5 日
DAY_OF_MONTH = 5 月中的某一天
HOUR = 10 时
MINUTE = 12 分
SECOND = 13 秒
Calendar calendar = Calendar.getInstance();//多态(重点关注)
import java.util.Calendar;
import java.util.Date;
public class CalendarExercise {
public static void main(String[] args) {
//Calendar calendar = Calendar.getInstance();//多态
//System.out.println(calendar);//从写toString方法
//demoOne();
//demoTwo();
demoThree();
//demoFour();
}
private static void demoFour() {
Calendar calendar = Calendar.getInstance();
Date date = calendar.getTime();
System.out.println(date);
}
private static void demoThree() {
Calendar calendar = Calendar.getInstance();
calendar.add(Calendar.YEAR,2); // 正为加，负为减
calendar.add(Calendar.MONTH,-3);
System.out.println(calendar.get(Calendar.YEAR));
System.out.println(calendar.get(Calendar.MONTH));
}
private static void demoTwo() {
Calendar calendar = Calendar.getInstance();
calendar.set(Calendar.YEAR,9999); // 设置日期
//calendar.set(888,88,88);
System.out.println(calendar.get(Calendar.YEAR));
}
private static void demoOne() {
Calendar calendar = Calendar.getInstance();
int year = calendar.get(Calendar.YEAR);
System.out.println(year);
int month = calendar.get(Calendar.MONTH);//西方是0-11
System.out.println(month);
int dateOfMonth = calendar.get(Calendar.DAY_OF_MONTH);
System.out.println(dateOfMonth);
}
}
System.CurrentTimeMillis()方法
public class CurrentTimeMillisExercise {
public static void main(String[] args) {
demoOne();
}
private static void demoOne() {
long start = System.currentTimeMillis(); //获取毫秒值
for (int i = 0; i <9999; i++) {
System.out.println(i);
}
long end = System.currentTimeMillis();
System.out.println("\n程序运行时间：" + (end-start) + "毫秒");
}
}
System.arraycopy(……)
System.arraycopy(object src,int srcPos,object dest,intdestPos,int length)：将数组中指定的数据拷贝到另一个数组
src：原数组
srcPos：原数组中的起始位置(索引)
dest：目标数组
destPos：目标数组中的起始位置
length：要复制的长度
import java.util.Arrays;
public class ArrayCopyExercise {
public static void main(String[] args) {
demo();
}
private static void demo() {
int[] src = {1,2,3,4,5};
int dest[] = {6,7,8,9,10};
System.out.println("复制前：" + Arrays.toString(dest));
System.arraycopy(src,0,dest,2,3); //从原数组(目标数组)要复制(被复制)的索引开始 + length <=src.length()/dest.length()
System.out.println("复制后：" + Arrays.toString(dest));
}
}
Stingbuilder
字符串缓冲区支持可变的字符串。
public class StringBuilderExercise {
public static void main(String[] args) {
demoOne();
demoTwo();
demoThree();
demoFour();
}
private static void demoFour() {
String string = "hello";
StringBuilder stringBuilder = new StringBuilder(string);
stringBuilder.append("world");
System.out.println(stringBuilder);
final String string1 = stringBuilder.toString();
System.out.println(string1);
}
private static void demoThree() {
StringBuilder stringBuilderOne = new StringBuilder();
stringBuilderOne.append("hello").append(123456789); // 链式编程
System.out.println(stringBuilderOne);
}
private static void demoTwo() {
//带参构造
StringBuilder stringBuilder = new StringBuilder("hello");
System.out.println(stringBuilder);
}
private static void demoOne() {
//空参构造方法
StringBuilder stringBuilder = new StringBuilder();
System.out.println(stringBuilder);
}
}

装箱和拆箱

装箱：基本数据类型-->包装类

拆箱：包装类-->基本数据类型

可以使用构造方法或者使用valueOf方法进行装箱(对字符串类型的数和基本数据类型)。

可以进行自动装箱和自动拆箱

基本数据类型和字符串类型之间相互转换

1、基本数据类型的值 + "" (最简单)

2、包装类的静态方法toString(参数)，和object是重载关系

3、String类的静态方法valueOf(参数)，将基本数据类型进行转换

1、使用包装类的静态方法parsexxx("数值类型的字符串")

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。