Java的数据类型分为两大类:
-
基本数据类型:包括 整数 、 浮点数 、 字符 、 布尔 。
-
引用数据类型:包括 类 、 数组 、 接口 。
基本数据类型
- 字节类型:byte
- 短整数类型:short
- 整数类型:int
- 长整数类型:long
- 单精度类型:float
- 双精度类型:double
- 字符类型:char
- 布尔类型:boolean
引用数据类型
- 类Class引用: Object、String、Date、Void、Integer、Long、Boolean、Byte、Character、Double、Float、Short
- 数组
- 接口 interface
继承
/*
* 定义员工类Employee,做为父类
*/
class Employee {
String name; // 定义name属性
// 定义员工的工作方法
public void work() {
System.out.println("尽心尽力地工作");
}
}
/*
* 定义讲师类Teacher 继承 员工类Employee
*/
class Teacher extends Employee {
// 定义一个打印name的方法
public void printName() {
// super(),调用父类构造方法(与类名相同的方法就是构造方法)
this.成员方法名() -- 本类的
super.成员方法名() -- 父类的
System.out.println("name=" + name);
}
}
/*
* 定义测试类
*/
public class ExtendsDemo01 {
public static void main(String[] args) {
// 创建一个讲师类对象
Teacher t = new Teacher();
// 为该员工类的name属性进行赋值
t.name = "小明";
// 调用该员工的printName()方法
t.printName(); // name = 小明
// 调用Teacher类继承来的work()方法
t.work(); // 尽心尽力地工作
}
}
抽象类
使用 abstract 关键字修饰方法,该方法就成了抽象方法,抽象方法只包含一个方法名,而没有方法体。 继承抽象类的子类必须重写父类所有的抽象方法。否则,该子类也必须声明为抽象类。
// 这个就是抽象类
public abstract class Employee {
public abstract void work();
}
public class Teacher extends Employee {
public void work (){
System.out.println("讲课");
}
}
public class Test {
public static void main(String[] args) {
// 创建子类对象
Teacher t = new Teacher();
// 调用run方法
t.work();
}
}
面向对象【接口,多态】
- 接口的定义,它与定义类方式相似,但是使用 interface 关键字。它也会被编译成.class文件,但一定要明确它并不是类,而是另外一种引用数据类型。
- 类与接口的关系为实现关系,即类实现接口,该类可以称为接口的实现类,也可以称为接口的子类。实现的动作类似继承,格式相仿,只是关键字不同,实现使用 implements 关键字
含有抽象方法
抽象方法:使用 abstract 关键字修饰,可以省略,没有方法体。该方法供子类实现使用。
含有默认方法和静态方法
默认方法:使用 default 修饰,不可省略,供子类调用或者子类重写。
静态方法:使用 static 修饰,供接口直接调用。
// 定义接口:
public interface LiveAble {
// 定义抽象方法
public abstract void eat();
public abstract void sleep();
// 默认方法
public default void sleep();
// 静态方法
public static void sleep();
}
// 定义实现类
public class Animal implements LiveAble {
//抽象方法必须在子类重写
@Override
public void eat() {
System.out.println("吃东西");
}
@Override
public void sleep() {
System.out.println("晚上睡");
}
}
// 定义测试类
public class InterfaceDemo {
public static void main(String[] args) {
// 创建子类对象
Animal a = new Animal();
// 调用实现后的方法
a.eat();
a.sleep();
}
}
fifinal,static,权限修饰符,内部类
public class FinalDemo1 {
public static void main(String[] args) {
// 声明变量,使用final修饰
final int a;
// 第一次赋值
a = 10;
// 第二次赋值0
a = 20; // 报错,不可重新赋值
// 声明变量,直接赋值,使用final修饰
final int b = 10;
// 第二次赋值
b = 20; // 报错,不可重新赋值
}
}
常用类库
-
Random
//1. 导包 import java.util.Random; public class Demo01_Random { public static void main(String[] args) { //2. 创建键盘录入数据的对象 Random r = new Random(); //3. 随机生成一个数据 int number = r.nextInt(33)+1; //4. 输出数据 System.out.println("number:"+ number); } } 备注:创建一个 Random 对象,每次调用 nextInt() 方法,都会生成一个随机数。
-
String类
String a = "aaa" String aa = "aaa" String b = "AAA" public boolean equals (Object anObject) :将此字符串与指定对象进行比较。 a.equals(b) 返回false a.equals(a) 返回true public boolean equalsIgnoreCase (String anotherString) :将此字符串与指定对象进行比较,忽略大小写。 a.equalsIgnoreCase(b) 返回true
-
Object类
-
Date类
// 创建日期对象 Date date = new Date(); //public long getTime()获取的是日期对象从1970年1月1日 00:00:00到现在的毫秒值 System.out.println(date.getTime()); //public void setTime(long time):设置时间,给的是毫秒值 date.setTime(0); System.out.println(date)
-
DateFormat类
import java.text.SimpleDateFormat;
import java.text.ParseException;
import java.utils.Date;
public static void main(String[] args) throws ParseException {
//格式化:从 Date 到 String
Date d = new Date();
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String s = sdf.format(d);
System.out.println(s);
System.out.println("--------");
//从 String 到 Date
String ss = "2048-08-09 11:11:11";
//ParseException
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date dd = sdf2.parse(ss);
System.out.println(dd);
}
- Calendar日历类
public static void main(String[] args) { // 创建Calendar对象 Calendar cal = Calendar.getInstance(); // 获取年 int year = cal.get(Calendar.YEAR); //设置年份为2020年 cal.set(Calendar.YEAR, 2020); //将年份修改为2000年 cal.add(Calendar.YEAR,-20) //将日历对象转换为日期对象 Date d = cal.getTime(); System.out.println(d); }
- Arrays
public static void main(String[] args){ int[] arr = {5,1,9,2,33,18,29,51}; //数组升序排列 Arrays.sort(arr); //数组转成字符串 String arrStr = Arrays.toString(arr); System.out.println(arrStr); //数组二分查找 int index = Arrays.binarySearch(arr,9); System.out.println(index); }
- Math
public static void main(String[] args){ //public static int abs(int a) 返回参数的绝对值 System.out.println( Math.abs(5)); //结果为5 System.out.println( Math.abs(-5)); //结果为5 //public static double ceil(double a) 返回大于或等于参数的最小double值,等于一个整数 System.out.println( Math.ceil(5.4)); //结果为6 //public static double floor(double a) 返回小于或等于参数的最大double值,等于一个整数 System.out.println( Math.ceil(5.5)); //结果为5 //public static int round(float a) 按照四舍五入返回最接近参数的int System.out.println( Math.ceil(5.5));//结果为6 System.out.println( Math.ceil(5.4));//结果为5 }
集合
Collection接口方法
public boolean add(E e) : 把给定的对象添加到当前集合中 。
public boolean addAll(Collection<? extends E>) 将另一个集合元素添加到当前集合中。
public void clear() :清空集合中所有的元素。
public boolean remove(E e) : 把给定的对象在当前集合中删除。
public boolean contains(Object obj) : 判断当前集合中是否包含给定的对象。
public boolean isEmpty() : 判断当前集合是否为空。
public int size() : 返回集合中元素的个数。
public Object[] toArray() : 把集合中的元素,存储到数组中。
如:
Collection<String> arr = new ArrayList<String>();
// 使用方法
// 添加功能 add(String s)
arr.add("11");
arr.add("22");
arr.add("33");
System.out.println(arr);
// 批量添加功能 addAll(String s)
arr1.add("444")
arr1.add("555")
arr1.add("666")
arr.addAll(arr1)
// 清空集合 clear(String s)
arr.clear()
// 把给定的对象在当前集合中删除 remove(String s)
arr.remove("11")
// 判断当前集合中是否包含给定的对象 contains(String s)
coll.contains("11")
以此类推isEmpty() size() toArray()
迭代器 Iterator
实现原理:使用hashNext()方法判断集合中是否存在下一个元素,如果存在,则调用next()方法将元素取出,否则说明已到达了集合末尾,停止遍历元素。
java.util.Iterator
public static void main(String[] args) {
// 使用多态方式 创建对象
Collection<String> coll = new ArrayList<String>();
// 添加元素到集合
coll.add("串串星人");
coll.add("吐槽星人");
coll.add("汪星人");
//遍历
//使用迭代器 遍历 每个集合对象都有自己的迭代器
Iterator<String> it = coll.iterator();
// 泛型指的是 迭代出 元素的数据类型
while(it.hasNext()){ //判断是否有迭代元素
String s = it.next();//获取迭代出的元素
System.out.println(s);
}
}
ArrayList 与 linkedList
-
ArrayList 增删慢,查找快。同上面Collection方法
-
linkedList 增删慢,查找快。
public void addFirst(E e) :将指定元素插入此列表的开头。 public void addLast(E e) :将指定元素添加到此列表的结尾。 public E getFirst() :返回此列表的第一个元素。 public E getLast() :返回此列表的最后一个元素。 public E removeFirst() :移除并返回此列表的第一个元素。 public E removeLast() :移除并返回此列表的最后一个元素。 public E pop() :从此列表所表示的堆栈处弹出一个元素。 public void push(E e) :将元素推入此列表所表示的堆栈。 public boolean isEmpty() :如果列表不包含元素,则返回true。
泛型
定义和使用含有泛型的类: 修饰符 class 类名<代表泛型的变量> { }
如:ArrayList<String> list = new ArrayList<String>();
含有泛型的方法:修饰符 <代表泛型的变量> 返回值类型 方法名(参数){ }
如:public class MyGenericMethod {
public <MVP> void show(MVP mvp) {
System.out.println(mvp.getClass());
}
public <MVP> MVP show2(MVP mvp) {
return mvp;
}
}
//调用时明确泛型类型
public static void main(String[] args) {
// 创建对象
MyGenericMethod mm = new MyGenericMethod();
// 演示看方法提示
mm.show("aaa");
mm.show(123);
mm.show(12.45);
}
含有泛型的接口 :
public interface MyGenericInterface<E>{
public abstract void add(E e);
public abstract E getE();
}
public class MyImp1 implements MyGenericInterface<String> {
@Override
public void add(String e) {
// 省略...
}
@Override
public String getE() {
return null;
}
}
public static void main(String[] args) {
Collection<String> list = new ArrayList<String>();
list.add("hello");
list.add("kaikeba");
// list.add(5);//当集合明确类型后,存放类型不一致就会编译报错
// 集合已经明确具体存放的元素类型,那么在使用迭代器的时候,迭代器也同样会知道具体遍历元素类型
Iterator<String> it = list.iterator();
while(it.hasNext()){
String str = it.next();
//当使用Iterator<String>控制元素类型后,就不需要强转了。获取到的元素直接就是String类型
System.out.println(str.length());
}
}
泛型通配符基本使用
public static void main(String[] args) {
Collection<Intger> list1 = new ArrayList<Integer>();
getElement(list1);
Collection<String> list2 = new ArrayList<String>();
getElement(list2);
}
//?为通配符,可以接收任意类型
public static void getElement(Collection<?> coll){
Iterator<?> it = coll.iterator();
while(it.hasNext()){
System.out.println(it.next());
}
}
通配符高级使用----受限泛型
泛型的上限:
格式: 类型名称 <? extends 类 > 对象名称
意义: 只能接收该类型及其子类
泛型的下限:
格式: 类型名称 <? super 类 > 对象名称
意义: 只能接收该类型及其父类型
public abstract class Employee {
private String name;
private int age;
public Employee() {
}
public Employee(String name, int age) {
this.name = name;
this.age = age;
}
//省略get/set
public abstract void work();
}
public static void getElement(List<? extends Employee> list){
Iterator<? extends Employee> it = list.iterator();
while (it.hasNext()){
Employee employee = it.next();
System.out.println(employee.getName()+"::"+employee.getAge());
employee.work();
}
}
调用方法:
getElement(managerList);
IO流
File类
创建方法:
public File(String pathname) :通过将给定的路径名字符串转换为抽象路径名来创建新的 File实例。
public File(String parent, String child) :从父路径名字符串和子路径名字符串创建新的 File实例。
public File(File parent, String child) :从父抽象路径名和子路径名字符串创建新的 File实例。
public static void main(String[] args){
// 文件路径名
String pathname = "D:\\aaa.txt";
File file1 = new File(pathname);
System.out.println(file1);
// 通过父路径和子路径字符串
String parent = "d:\\aaa";
String child = "bbb.txt";
File file2 = new File(parent, child);
System.out.println(file2);
// 通过父级File对象和子路径字符串
File parentDir = new File("d:\\aaa");
String child = "bbb.txt";
File file3 = new File(parentDir, child);
System.out.println(file3);
}
获取方法:
public String getAbsolutePath() :返回此File的绝对路径名字符串。
public String getPath() :将此File转换为路径名字符串。
public String getName() :返回由此File表示的文件或目录的名称。
public long length() :返回由此File表示的文件的长度。
public File getParentFile() 返回由此File表示的文件或目录的父目录,如果没有父目录,返回null
public static void main(String[] args) {
File f = new File("d:/aaa/bbb.java");
System.out.println("文件绝对路径:"+f.getAbsolutePath());
System.out.println("文件构造路径:"+f.getPath());
System.out.println("文件名称:"+f.getName());
System.out.println("文件长度:"+f.length()+"字节");
System.out.println("文件路径的父路径"+f.getParentFile());
File f2 = new File("d:/aaa");
System.out.println("目录绝对路径:"+f2.getAbsolutePath());
System.out.println("目录构造路径:"+f2.getPath());
System.out.println("目录名称:"+f2.getName());
System.out.println("目录长度:"+f2.length());
System.out.println("目录父路径"+f2.getParentFile());
}