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());
}
