1、ArrayList的学习
ArrayList构造方法和添加方法
- public ArrayList() 创建一个空的集合对象
- public Boolean add(E e) 将指定的元素追加到此集合的末尾
- public void add(int index,E element) 在此集合的指定位置插入指定元素
1、
import java.util.ArrayList;
public class ArrayListDemo01 {
public static void main(String[] args) {
ArrayList<String> array = new ArrayList<>();
System.out.println(array.add("hello"));
array.add(1,"java");
System.out.println("array:" +array);
}
}
2、
-public Boolean remove（Object o）：删除指定的元素，返回删除是否成功
- public E remove（int index）：删除指定索引处的元素，返回被删除的元素
- public E set(int index,E element ):删除指定索引处的元素，返回被修改的元素
- public E get(int index):返回索引处的元素
- public int size():返回集合中的元素的个数
import java.util.ArrayList;
public class ArrayListDemo01 {
public static void main(String[] args) {
ArrayList<String> array = new ArrayList<>();
array.add("hello");
array.add("world");
array.add("java");
// array.add(1,"java");
System.out.println(array.set(2,"javaee"));
System.out.println(array.remove("world"));
System.out.println(array.get(1));
System.out.println(array.size());
System.out.println("array"+array);
}
}
输出结果：
java
true
javaee
2
array[hello, javaee]
3、遍历
import java.util.ArrayList;
public class ArrayListDemo02 {
public static void main(String[] args) {
ArrayList<String> array = new ArrayList<>();
array.add("hello");
array.add("world");
array.add("java");
/* System.out.println(array.get(0));
System.out.println(array.get(1));
System.out.println(array.get(2));*/
for (int i=0;i<array.size();i++){
// System.out.println(array.get(i));
String s = array.get(i);
System.out.println(s);
}
}
}
输出
hello
world
java
4、ArrayList 存储学生对象并遍历
import java.util.ArrayList;
public class ArrayListDemo3 {
public static void main(String[] args) {
//创建集合对象
ArrayList<Student> array = new ArrayList<>();
//创建学生对象
Student stu1 = new Student("weblv",30);
Student stu2 = new Student("ljx",23);
//添加学生对象到集合中
array.add(stu1);
array.add(stu2);
//遍历集合，采用通用遍历格式实现
for(int i=0;i<array.size();i++){
Student s = array.get(i);
System.out.println(s.getName() + ','+s.getAge());
}
}
}
输出
weblv,30
ljx,23
5、ArrayList 存储学生对象并遍历（升级）
import java.util.ArrayList;
import java.util.Scanner;
public class ArrayListDemo04 {
public static void main(String[] args) {
ArrayList<Student> array =new ArrayList<Student>();
//调用方法
AddStu(array);
AddStu(array);
AddStu(array);
//输出对象
for (int i=0;i<array.size();i++){
Student s = array.get(i);
System.out.println(s.getName() +',' +s.getAge());
}
}
public static void AddStu(ArrayList<Student> array){
//键盘录入学生对象所需的数据
Scanner sc = new Scanner(System.in);
System.out.println("请输入学生姓名：");
String name = sc.nextLine();
System.out.println("请输入学生年龄");
String age = sc.nextLine();
//创建学生对象，把键盘录入的数据赋值给学生对象的成员变量
Student s = new Student();
s.setName(name);
s.setAge(age);
//集合中添加学生对象
array.add(s);
}
}
请输入学生姓名：
hah
请输入学生年龄
13
请输入学生姓名：
xkx
请输入学生年龄
14
请输入学生姓名：
adq
请输入学生年龄
12
hah,13
xkx,14
adq,12
6、
Alt+Ins 根据自己需要构造方法
2、继承
1、格式：public class 子类名 extends 父类名{}
2、继承的好处和弊端：
好处
- 提高代码复用性（多个类相同的成员可以放到同一个类中）
- 提高了代码的维护性（方法的代码需要修改，修改一处即可）
弊端
- 继承让类之间产生了关系，削弱了子类的独立性
3、继承中变量的访问特点
在子类方法中访问一个变量
- 子类局部范围找——>子类成员范围找--->父类成员范围找（如果都没有，则报错）
4、super关键字
public class Zi extends Fu {
public int age = 20;
public void show(){
int age = 30;
System.out.println(age);
//访问本类的成员变量age
System.out.println(this.age);
//访问父类的成员变量age
System.out.println(super.age);
}
}
5、继承中构造方法的访问特点
子类中所有的构造方法默认都会访问父类中无参的构造方法
- 子类会继承父类中的数据，可能还会使用父类的数据，所以子类初始化之前，一定先完成父类数据的初始化
- 每一个子类构造方法的第一条语句默认都是super
如果父类中没有无参构造方法，只有带参构造方法，怎么办？
- 通过使用super关键字显示的调用父类的带参构造方法
- 在父类中自己提供一个无参的构造方法（推荐）
6、继承中访问成员方法的访问特点
通过子类对象访问一个方法、
- 子类成员范围找
- 父类成员范围找
- 如果都没有则报错
7、方法重写
概述：
- 子类中出现和父类一模一样二点方法声明
方法重写的应用：
- 当子类需要父类的功能，而功能主体子类又有自己的内容十，可以重写父类中的方法，这样，既沿袭了父类的功能，有定义了子类特有的功能
@Override ：帮助我们检查方法重写声明的正确性
- 方法重写注意事项：
1、私有方法不能被重写（父类的私有成员子类是不能继承的）
==子类访问权限不能更低（public > 默认（就是直接void ,没有修饰符） > 私有） ==
8、Java中继承的注意事项
- Java类只支持单继承，不支持多继承
- Java类中支持多层继承
9、继承实例
public class Person {
public String name;
public String age;
//无参构造
public Person() {
}
//带参构造
public Person(String name,String age){
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getAge() {
return age;
}
public void setAge(String age) {
this.age = age;
}
}
public class Students extends Person{
public Students(){
}
public Students(String name,String age){
super(name,age); // 继承父类中的带参方法
}
public void Study(){
System.out.println("我是学生，我爱学习！");
}
}
3、修饰符
1、包
1、概述：就是文件夹，对类进行分类管理
2、定义格式 ： package 包名.（多级包用.分开）
2、导包
使用不同包下的类时，简化带包的操作，使用import将其他包导入，并使用其他包下的类
- 格式:import 包名
3、状态修饰符
-
final(最终态):可修饰成员方法，成员变量，类
-
特点：
1、修饰方法：表明该方法是最终方法，不能被重写
2、修饰变量：表明该变量是常量，不能被再次赋值
3、修饰类：表明该类是最终类，不能被继承
final修饰局部变量：
-
变量是基本类型：final修饰指的是基本类型数据值不能发生改变
-
变量是引用类型：final修饰指的是引用类型的地址值不能发生改变，但是地址值里面的内容是可以发生改变的
-
static(静态)：可修饰成员方法，成员变量
-
特点：
1、被类的所有对象共享（这也是我们判断是否使用静态变量关键字的条件）
2、可用通过类名调用，也能使用对象名进行调用（推荐使用类名调用）
public class Student01 {
public String name;
public int age ;
public static String university; //
public void show(){
System.out.println(name + "," + age + "," + university);
}
}
public class staticDemo {
public static void main(String[] args) {
Student01.university = "厦门大学";//直接用类中的参数进行赋值，直接通过类名访问，使得默认值为厦门大学
Student01 s1 = new Student01();
s1.name="lwb";
s1.age=10;
//s1.university="厦门大学";
s1.show();
Student01 s2 =new Student01();
s2.name = "ljx";
s2.age = 11;
s2.show();
}
}
输出
lwb,10,厦门大学
ljx,11,厦门大学
static 访问特点
非静态的成员方法：
- 能访问静态的成员变量
- 能访问非静态的成员变量
- 能访问静态的成员方法
- 能访问静态的成员方法
静态的成员方法：
- 能访问静态的成员变量
- 能访问静态的成员方法
静态成员只能访问静态成员
4、多态
1、同一个对象，在不同时刻表现出来的不同形态
猫 cat = new 猫（）；
也可以 动物 Animal = new 猫（）；
多态的前提和体现：
- 有继承/实现关系
- 有方法重写
- 有父类引用指向子类对象
2、多态中成员的访问特点
package Test01;
public class Animal {
public int age = 40;
public void eat(){
System.out.println("动物吃东西");
}
}
package Test01;
public class Cat extends Animal {
public int age = 20;
public int weight = 10;
@Override
public void eat() {
System.out.println("猫吃鱼");
}
public void playgame(){
System.out.println("猫捉迷藏");
}
}
package Test01;
public class AnimalDemo {
public static void main(String[] args) {
Animal a = new Cat();
System.out.println(a.age);
a.eat();
//a.playgame(); 会报错，因为Animal中没有该方法
}
}
输出
40
猫吃鱼
- 成员方法：编译看左边，执行看右边
- 成员变量：编译看左边，执行看左边
因为成员方法有重写，而成员变量没有
3、多态的好处和弊端
- 好处：提高了程序的拓展性
具体体现：定义方法时，使用父类作为参数，将来在使用的时候，使用具体子类参与操作（多态只能访问共有的功能）
- 弊端： 泵使用子类的特有功能
4、多态的转型
- 向上转型
从子到父
父类引用指向子类对象 - 向下转型
从父到子
父类引用转为子类对象
package Test01;
public class AnimalDemo {
public static void main(String[] args) {
//多态
Animal a = new Cat(); //向上转型
a.eat();
((Cat) a).playgame();//向下转型
}
}
输出
猫吃鱼
猫捉迷藏
5、抽象类
1、概述
一个没有方法体的方法应该定义为抽象方法，而类中如果有抽象方法，该类必须定义为抽象类
package Test_Abstract;
public abstract class Animal {//定义抽象类
public abstract void eat();//定义抽象方法
}
2、抽象类的特点
- 抽象类和抽象方法必须使用abstract关键字修饰
public **abstract** clss 类名{}
public **abstract** void 方法名();
-
抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
-
抽象类不能直接实例化
++可以参照多态的方式，通过子类对象实例化，这叫抽象类多态++
-
抽象类的子类
要么重写抽象类中的所有抽象方法
要么是抽象类
3、抽象类的成员特点
- 成员变量(可以是变量，也可以是常量)
- 构造方法(有构造方法，但是不能实例化，构造方法用于子类访问父类数据的初始化)
- 成员方法(可以有抽象方法：限定子类必须完成某些动作；也可以有非抽象方法：提高代码的复用性)
6、接口
1、概述：接口就是一种公用的规范，Java中的接口更多体现在对行为的抽象
2、特点
- 接口用关键字interface修饰
public interface 接口名{}
- 类实现接口用implements表示
public class 类名 implements 接口名{}
- 接口不能实例化
- 接口参照多态的方式，通过实现类对象实例化，这叫接口多态
- 多态的形式：抽象类多态，接口多态
- 多态的前提：有几成或者实现关系；有方法重写；有父类(类/接口)引用指向(子/实现)类对象
- 接口的实现类
要么重写接口中的所有抽象方法
要么是抽象类
3、接口的成员特点
- 成员变量
- 只能是常量
- 默认修饰符：public static final
- 构造方法
- 接口没有构造方法，因为接口主要是对行为进行抽象的，是没有具体存在的
- 一个类如果没有父类，默认继承Object类
- 成员方法
- 只能是抽象方法
- 默认修饰符：public abstract
4、类和接口的关系
- 类和类的关系
继承关系，只能单继承，但是可以多层继承
- 类和接口的关系
实现关系，可以单实现，也可以多实现，还可以继承一个类的同时实现多个接口
- 接口和接口的关系
继承关系，可以单继承，也可以多继承
5、抽象类和接口的区别
- 成员区别
- 抽象类---->常量、变量；有构造方法，有抽象方法。也有非抽象方法
- 接口------>常量；抽象方法
- 关系区别
- 类与类--------->继承、单继承
- 类与接口------->实现、可以单实现，也可以多实现
- 接口与接口----->继承，单继承，多继承
- 设计理念的区别
- 抽象类---->对类抽象，包括属性、行为
- 接口------>对行为抽象，主要是行为
/*
门与报警器
*/
public abstract interface Jumpping {
public abstract void Jump();
}
public interface Alram{
void alarm;
}
public abstract class Door(){
public abstract void open();
public abstract void close();
}
public class AkarnDoor extends Door implements Alarm{
public void open(){//重写方法
//...
}
public void close(){//重写方法
//...
}
public void alram(){//重写方法
//...
}
}
6、类名作为形参和返回值
- 方法的形参是类名，其实需要的是该类的对象
- 方法的返回值是类名，其实返回的是该类的对象（需要进行声明对象）
7、接口名作为形参和返回值
- 方法的形参是类名，其实需要的是该接口的对象
- 方法的返回值是类名，其实返回的是该接口的对象（需要进行声明对象）
7、内部类
1、格式
public class 类名{
修饰符 class 类名{
}
}
2、访问特点
- 内部类可以直接访问外部类的成员，包括私有
- 外部类要访问内部类的成员，必须创建对象
3、成员内部类
按照内部类在类中定义的位置不同，可以分为一下两种形式
- 在类的成员位置：成员内部类
- 在类的局部位置：局部内部类
成员内部类，外界如何创建对象使用呢？ - 格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象
- 范例：Outer.Inner oi = new Outer().new Inner(;
package InnerOutter;
public class Outer {
private int num = 10;
public class Inner{
private void show(){
System.out.println(num);
}
}
public void method(){//通过外部类调用内部类方法来实现
Inner i = new Inner();
i.show();
}
}
-----------------------------
package InnerOutter;
public class OuterTest {
public static void main(String[] args) {
/* Outer.Inner oi = new Outer().new Inner();
oi.show();*/
Outer o = new Outer();
o.method();
}
}
输出
10
4、局部内部类
局部内部类是在方法中定义的类，所以外界是无法直接访问的，需要在方法内部创建对象并使用该类可以直接访问外部类的成员，也可以访问方法内的局部变量
package InnerOutter;
public class Outer {
private int num = 10;
public void method(){//通过外部类调用内部类方法来实现
int num2 = 20;
class Inner{
public void show(){
System.out.println(num);
System.out.println(num2);
}
}
Inner i = new Inner();
i.show();
}
}
------------------------------------
package InnerOutter;
public class OuterTest {
public static void main(String[] args) {
/* Outer.Inner oi = new Outer().new Inner();
oi.show();*/
Outer o = new Outer();
o.method();
}
}
输出
10
20
5、匿名内部类(局部内部类特殊形式)
- 格式
new 类名或接口名(){
重写方法；
}
本质：是一个继承该类或者实现该接口的子类匿名对象
public interface Inter {
void show();
}
-------------------------------
public class Outer {
public void method(){//
Inter i= new Inter(){
@Override
public void show() {
System.out.println("匿名内部类");
}
};
i.show(); // 调用show方法
}
}
-------------------- ---------
package InnerOutter;
public class OuterTest {
public static void main(String[] args) {
/* Outer.Inner oi = new Outer().new Inner();
oi.show();*/
Outer o = new Outer();
o.method();
}
}
输出
匿名内部类
6、匿名内部类在开发中的使用
package Inner;
public class Cat implements Jumpping {
@Override
public void junp() {
System.out.println("我会跳高");
}
}
----------------------------------
package Inner;
public interface Jumpping {
void junp();
}
====================================
package Inner;
public class JumppingOperator {
public void method(Jumpping j){
j.junp();
}
}
--------------------------------
package Inner;
public class TestDemo {
public static void main(String[] args) {
Jumpping j = new Cat();
j.junp();
JumppingOperator jo = new JumppingOperator();
jo.method(j);
jo.method(new Jumpping() {//直接通过接口实例化对象调用匿名对象类，不用每次都新建一个类
@Override
public void junp() {
System.out.println("我也会跳高了");
}
});
}
}
输出
我会跳高
我会跳高
我也会跳高了
8、API
1、Math
查看文档
2、System
package Math;
public class Math {
public static void main(String[] args) {
System.out.println("开始");
System.exit(0);//中止当前Java虚拟机，非零表示异常
System.out.println("结束");
System.out.println(System.currentTimeMillis());//返回当前时间
}
}
3、Object类中的toString()方法
看方法，选中方法，按下crtl+B
- 建议子类重写object中的toString()方法
通过Alt+Ins中的toString()重写自动生成
4、Object类中的equals()方法
- 建议子类重写object中的equals()方法
通过Alt+Ins中的equals()重写自动生成,把hashmap()方法删除即可
5、Integer 类的概述和使用
- public static Integer valueOf(int i) 返回表示指定的int值的Integer实例
- public static Integer valueOf(String s) 返回一个保存指定值的Integer对象String
package Inter;
public class InterDeno {
public static void main(String[] args) {
Integer i = Integer.valueOf(100);
System.out.println(i);
Integer i1 = Integer.valueOf("100");
System.out.println(i1);
}
}
输出
100
100
5、int和String 的相互转化
- Int----->String
public static String valueOf(int i) 静态方法(String中的方法)
- String------->Int
public static int parseInt(String s)静态方法(Integer类中的方法)
package Inter;
/*
int和String的转换
*/
public class InterDeno {
public static void main(String[] args) {
//Int----->String
//方式1
int number = 100;
String s1 = ""+number;
System.out.println(s1);
//方式2 public static String valueOf(int i) 静态方法
String s2 = String.valueOf(number);
System.out.println(s2);
System.out.println("-----------------");
//String------->Int
String s3 ="100";
//方式一 String----->Integer----->int
Integer i = Integer.valueOf(s3);
//public int intValue()
int x = i.intValue();
System.out.println(x);
//方式2
//public static int parseInt(String s)静态方法
int y = Integer.parseInt(s3);
}
}
6、int和String 的相互转化（字符串转换案例）
package Inter;
import java.util.Arrays;
public class IntegerTest {
public static void main(String[] args) {
//定义一个字符串
String s = "91 27 46 38 50";
//用空格获取每一个元素放在数组中
String[] strArray = s.split(" ");
/* for (int i= 0;i<strArray.length;i++){
System.out.println(strArray[i]);
}*/
//定义一个int数组，把String[]数组中的每一个元素存储到int数组中
int[] arr = new int[strArray.length];
for (int i = 0;i<arr.length;i++){
arr[i] = Integer.parseInt(strArray[i]);
}
//对数组进行排序
Arrays.sort(arr);
//把排序后的int数组中的元素进行拼接得到一个字符串，用StringBuilder实现
StringBuilder sb = new StringBuilder();
for (int i = 0;i<arr.length;i++){
if(i == arr.length-1){
sb.append(arr[i]);
}else {
sb.append(arr[i]).append(" ");
}
}
String result = sb.toString();
System.out.println(result);
}
}
输出
27 38 46 50 91
6、自动拆箱和装箱
- 装箱：把基本数据类型转换为对应的包装类类型
Integer i= Integer.valueOf(100);//手动装箱
Integer ii = 100;//自动装箱
- 拆箱：把包装类类型转化为对应的基本数据类型
ii = ii.valueOf()+200;//手动装箱
ii += 200;//自动装箱 和上面语句一样结果
//i = i+200;i+200自动拆箱；i = i+200;自动装箱
在使用包装类类型的时候，如果做操作，最好先判断是否为null,只要是对象，在使用前就必须进行不为null的判断
4、Date
1、SimpleDateFormat
- y 年
- M 月
- d 日
- H 时
- m 分
- s 秒
2、SimpleDateFormat格式化和解析日期
- 格式化(从Date到String)
public final String format(Date date)：将日期格式化成日期/时间字符串
- 解析(从String到Date)
public Date parse(String source)：从给定字符串的开始解析文本以生成日期
package Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateDemo {
public static void main(String[] args) throws ParseException {
Date d1 = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒");
String s = sdf.format(d1);
System.out.println(s);
String s1 = "2020-03-16 11:11:11";
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date p = sdf1.parse(s1);
System.out.println(p);
}
}
输出
2020年03月16日 16时16分33秒
Mon Mar 16 11:11:11 CST 2020
3、日期工具类案例
- 需求：定义一个工具类DateUtils，包含两个方法，把日期转换为指定格式的字符串；把字符串解析为指定格式的日期，在测试类中调用实现
package Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class DateUtils {
public DateUtils() {
}
public static String dateToString(Date date, String format){
SimpleDateFormat sdf = new SimpleDateFormat(format);//按照传入格式创建对象
String s = sdf.format(date); // 把传入的日期转化成指定格式的字符串
return s;
}
public static Date stringToDater(String s, String format) throws ParseException {
SimpleDateFormat sdf = new SimpleDateFormat(format);
Date p = sdf.parse(s); //Artl+Enter创建抛出异常
return p;
}
}
//测试类
package Date;
import java.text.ParseException;
import java.util.Date;
public class DateDemo {
public static void main(String[] args) throws ParseException {
Date d1 = new Date();
String s1 =DateUtils.dateToString(d1,"yyyy年MM月dd日 HH:mm:ss");
System.out.println(s1);
String s2= DateUtils.dateToString(d1, "yyyy年MM月dd日");
System.out.println(s2);
System.out.println("--------------");
String s = "2012-01-01 12:12:12";
Date date = DateUtils.stringToDater(s, "yyyy-MM-dd HH:mm:ss");
System.out.println(date);
}
}
输出
2020年03月16日 16:40:00
2020年03月16日
--------------
Sun Jan 01 12:12:12 CST 2012
4、Calendar类
Calendar rightNow = Calendar.getlnstance();getlnstance()获取Calendar对象，其日历字段已使用当前日期和时间初始化
package Calendar;
import java.util.Calendar;
public class CalendarDemo {
public static void main(String[] args) {
Calendar c = Calendar.getInstance();
int i = c.get(Calendar.YEAR);
int i1 = c.get(Calendar.MONTH) + 1;
int i2 = c.get(Calendar.DATE);
System.out.println(i+"年"+i1+"月");
}
}
输出
2020年3月16日
5、Calendar类中的add,set方法
package Calendar;
import java.util.Calendar;
public class CalendarDemo {
public static void main(String[] args) {
Calendar c = Calendar.getInstance();
int i = c.get(Calendar.YEAR);
int i1 = c.get(Calendar.MONTH) + 1;
int i2 = c.get(Calendar.DATE);
System.out.println(i+"年"+i1+"月"+i2+"日");
System.out.println("-------------");
c.add(Calendar.YEAR,-3);// .add(int field,int amount)将指定的时间量加上或减去给定的日历字段
int k = c.get(Calendar.YEAR);
int k1 = c.get(Calendar.MONTH) + 1;
int k2 = c.get(Calendar.DATE);
System.out.println(k+"年"+k1+"月"+k2+"日");
System.out.println("-------------");
c.set(2058,11,11);// .set(int year,int month,int day)设置当前的年日月
int l = c.get(Calendar.YEAR);
int l1 = c.get(Calendar.MONTH) + 1; //月是从0开始算起的
int l2 = c.get(Calendar.DATE);
System.out.println(l+"年"+l1+"月"+l2+"日");
}
}
输出
2020年3月16日
-------------
2017年3月16日
-------------
2058年12月11日
5、Calendar类案例分析（计算二月天数）
package Calendar;
import java.util.Calendar;
import java.util.Scanner;
public class Cal {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("请输入你要查询的年份：");
int year = sc.nextInt();
Calendar c = Calendar.getInstance();
c.set(year,2,1);
c.add(Calendar.DATE,-1);
int date = c.get(Calendar.DATE);
System.out.println(year+"年的二月份有"+date+"天");
}
}
输出
请输入你要查询的年份：
2048
2048年的二月份有29天