时间戳

首页 > 技术文章 > java03-java基础

java03-java基础

ylrcblogs 2021-01-05 14:34 原文

java基础

1. java的数据类型转换

java是强类型语言，安全性会比较好，但是运行的速度会有一丢丢的影响

类型转换：

低------------------------------------------------------------->高

byte,short ,char--->int --->long--->float---->double

  • 运算中，不同类型的数据先转换成一样类型的数据，然后在进行计算
  • 低转高，自动类型转换
  • 高转低，强制类型转换
    • 注意点：会出现内存溢出的问题，导致数据不准确

2.加强for

  • 加强for一般用在数组和集合的遍历上
int[] numbers = [10,20,30,40];
for(int x : numbers){
    System.out.print(x);
}

3.方法的重载

定义：在一个类中，有相同的函数名称，但参数类型不同（可以是参数的个数不同，也可以是类型不同）；

  • 在调用方法的时候，java的虚拟机会根据不用的参数，执行不同的方法；

4.可变参数的方法

  1. 可变参数，方法参数类型的后面加 三个点 ...
  2. 可变的参数值能放在方法参数的最后面
public void max(int index,double... numbers){
    // 方法体
}

5.方法的重写

重写

  • 重写：子类继承父类，在子类中重写父类的方法；方法名，参数，返回值都相同；

6.static 和 final

static

  • static 修饰的方法和属性，是属于类所有的（初始化加载）调用：类名.方法名；
  • static 静态方法不能使用类的非静态变量
  • static 静态代码块
    • 当类别加载时，静态代码块会被执行，由于类只加载一次，所以静态代码块也只执行一次;
    • 在程序中，通常会使用静态代码块来对类的成员变量进行初始化

final

  • final 可用于修饰类，变量，方法（无法改变，最终）
  • final 修饰类，不能被继承；
  • final 修饰方法，不能被子类重写；
  • final 修饰变量，是常量，只能被赋值一次；

7.抽象

抽象类

  1. 声明抽象类（abstract），不能被实例化，成员变量，成员方法，构造函数和普通的类一样；
  2. 子类继承抽象类（extents）后，必须实现抽象类中的抽象方法；
  3. 抽象类中的非抽象方法，由于抽象类不能被实例化，所以不能使用，但可以在子类实例化后使用；

抽象方法

  1. 如果一个类中包含抽象方法，那么这个类必须是一个抽象类；
  2. 任何子类必须重写抽象方法，或者自身也是抽象类；

8.接口

  1. 不能被实例化
  2. 没有构造方法
  3. 接口中一般不定义变量，接口中变量的默认修饰符为 final static
  4. 一个类能够同时实现多个接口
  5. interface接口，实现接口implements

9.多态

  • 在同一个方法中，由于参数的类型不同，而导致执行效果各异的现象就是多态；

  • 继承是多态实现的基础；

    interface Aniaml{
    void shout();
}

    class Cat implements Animal(){
	public void shout(){
        System.out.println("mao----")
    }
}

    class Dog implements Animal(){
	public void shout(){
        System.out.println("wang----")
    }
}

    public static void animalShout(Animal an){
    an.shout();
}

    public static void main(String[] agrs){
    Animal an1 = new Cat();
    Animal an2 = new Dog();
    animalShout(an1);
    animalShout(an2);
}

    注：多态不仅解决了方法名同名的问题，而且还是程序变得更加的灵活，从而有效的提高了程序的可扩展性和可维护性；

10.instanceof 关键字

  • 对象（或者对象应用变量）instanceof 类（或接口）

    if(cat instanceof Cat){
    //如果cat是Cat的一个实例化对象 则返回True
}

11.冒泡排序

int[] array = new int[5,6,2,3,1,4,9,8,7];
for (int i=0;i<array.length;i++){
    if (array[i] > array[i+1]){
        int num = array[i];
        array[i] = array[i+1];
        array[i+1] = num;
    }
}//冒泡排序：不断的比较两个相邻的元素的大小

12.构造方法

  1. 方法名与类名相同；
  2. 方法名前没有返回值类型的声明；
  3. 不能return一个值，但是可以单独写一个return作为方法的结束；
  4. 构造方法会在实例化对象时，自动被调用；

13.访问控制符

  • public ： 当前类 同一包 子孙类（同一包） 子孙类（不同包） 其他包

  • protected： 当前类 同一包 子孙类（同一包） 子孙类（不同包）（y/n）

    • 子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；
    • 子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。
    • protected 可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外）。

  • default： 当前类 同一包 子孙类（同一包）

  • private ： 当前类

14.异常

异常的分类

  • Error：代表程序中产生的错误；
  • Exception：代表程序中产生的异常；

15.集合

集合的体系

  • Collection：单列结合的根接口，用于存储一系列符合某种规则的元素，它有两个重要的子接口，分别是List和Set

    • List集合：元素有序，可重复；
    • Set集合：无序，不重复；

  • Map：双列集合类的根接口，用于存储具有键，值映射关系的元素；

15.1 Collection 接口的方法

  • boolean add(Object o) 向集合中添加一个元素
  • boolean addAll(Collection c) 将指定Collection中所有元素添加到该集合
  • void clear() 删除该集合中的所有元素
  • boolean remove(Object o) 删除该集合中指定元素
  • boolean removeAll(Collection c) 删除指定集合中的所有元素
  • boolean isEmpty() 判断该集合中是否为空
  • boolean containsAll(Collection c) 判断该集合中是否包含指定集合中的所有元素
  • Iterator iterator() 返回该集合的元素上进行迭代的迭代器，用于遍历该集合所有元素
  • int size() 获取该集合元素的个数

List 集合

List 接口添加一些特有的方法

  • void add( int index ,Object element) 将元素element插入在List集合的index处
  • boolean addAll(int index,Collection c) 将集合c中所有的元素插入到List集合的index处
  • Object get (int index) 返回集合索引index处的元素
  • Object remove (int index) 删除集合index处的元素
  • Object set (int index, Object element) 将索引index处元素替换成element对象，并将替换后的元素返回
  • int indexOf (Object o) 返回对象在集合中出现的索引
  • int lastIndexOf( Object o) 返回对象o在List集合中最后一次出现的索引
  • List SubList(int fromIndex,int toIndex) 返回从索引fromIndex到toIndex处的所有元素集合组成的子元素

集合ArrayList 和集合 LinkedList比较

  1. 集合ArrayList是List接口的实现类，ArrayList集合中封装了一个长度可变的数组对象，因此可以将ArrayList 集合看做一个长度可变的数组；
  2. ArrayList 集合在查询元素是速度很快，但是增删元素是效率较低；
  3. 为了克服ArrayList 的局限性，LinkedList集合对于元素的增删操作具有很高的效率；

Set 接口

简介

  1. Set同样继承于Collection 接口，他中Collection接口中的方法基本一致；
  2. Set接口与List接口不同的是：Set接口中的元素是无序的，并且都会以某种规则保证存入的元素不会出现重复；

HashSet

  1. HashSet是Set接口的一个实现类

15.2 Iterator接口

  1. 目的：遍历集合中的所有元素；

  2. Iterator 接口也是集合中的一员，Collection和Map接口主要用于存储，而Iterator 主要用于迭代访问，即遍历；

  3. 举例 Iterator的使用

    public static void main(String[] args){
    ArrayList list = new ArrayList;
    list.add("data_1");
    list.add("data_2");
    list.add("data_3");
    list.add("data_4");
    Iterator it = list.iterator();
    while (it.hasNext()){
        Object obj = it.next();
        System.out.println(obj);
    }
}

15.3 Map接口

简介

  • Map接口是一种双列集合，每个元素都包含一个键对象Key 和值对象 Value，键和值对象之间存在一种对应的关系，称为映射；
  • Map 集合中常用方法
    • void put (Object key,Object value) 将指定的值与此映射中的指定键关联
    • Object get (Object key) 返回指定键所映射的值；若果此映射不包含该键的映射关系，则返回null
    • boolean containsKey(Object key ) 如果此映射包含指定键的映射关系，则返会true
    • boolean containsValue(Object value) 如果此映射将一个或者多个键映射到指定值 则返回true
    • Set keySet() 返回此映射中包含键的Set视图
    • Collection values() 返回此映射中包含的值Collection视图
    • Set<Map.Entry<K,V>>entrySet() 返回此映射中包含的映射关系的Set视图

HashMap集合

简介

  1. HashMap集合是Map接口的实现类；

Hashtable 集合

简介

  1. Hashtable 和 HashMap集合十分相似，区别：Hashtable是线程安全的，Hashtable存取元素是速度很慢，基本被HashMap取代；
  2. Hashtable有一个子类 Properties 实际应用中非常重要；

properties集合

  1. Properties主要用于存储字符串类型的键和值

  2. 例子：

    Properties p = new Properties();
p.setProperties("Backgroup","red");
p.setProperties("Font-size","14px");
p.setProperties("Language","Chinese");
Enumeration names = p.propertyNames();
while(names.hasMoreElements()){					//循环获取所有的键
    String key = (String)names.nextElement();
    String value = p.getProperty(key);			//获取对应键的值
    System.out.println(key + "=" + value);
}

推荐阅读