JAVA 基础

72 阅读9分钟

Java的数据类型分为两大类:

  1. 基本数据类型:包括 整数 、 浮点数 、 字符 、 布尔 。
    
  2. 引用数据类型:包括 类 、 数组 、 接口 。
    

基本数据类型

  1. 字节类型:byte
  2. 短整数类型:short
  3. 整数类型:int
  4. 长整数类型:long
  5. 单精度类型:float
  6. 双精度类型:double
  7. 字符类型:char
  8. 布尔类型:boolean

引用数据类型

  1. 类Class引用: Object、String、Date、Void、Integer、Long、Boolean、Byte、Character、Double、Float、Short
  2. 数组
  3. 接口 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();

    }

}

面向对象【接口,多态】

  1. 接口的定义,它与定义类方式相似,但是使用 interface 关键字。它也会被编译成.class文件,但一定要明确它并不是类,而是另外一种引用数据类型。
  2. 类与接口的关系为实现关系,即类实现接口,该类可以称为接口的实现类,也可以称为接口的子类。实现的动作类似继承,格式相仿,只是关键字不同,实现使用 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()获取的是日期对象从19701100: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

  1. ArrayList 增删慢,查找快。同上面Collection方法

  2. 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());

}