复习（面向对象，常用类，集合）

面向对象
对象与引用
方法调用传递参数时 的分为两种

值传递（形参数据类型为基本数据类型）： 方法执行中形参数据的改变不影响实参的值 是两个独立的变量

引用传递（形参数据类型是引用数据类型）：方法执行中形参数据的改变影响实参的值 传递的是对象的地址 实参，形参指向同一个对象

this关键字
this在类中表示正在访问的对象

区分成员变量，局部变量

static
修饰成员变量，方法，代码块，内部类

修饰属性
成员变量也成为类变量 类有共同属性时使用static 内存空间只有一份 所有对象可共享 定义之初即可赋值

修饰内容：

随类的加载而加载，通过类名加载

修饰成员方法（类方法）
方法使用非静态成员变量，则方法不能被定义为静态的，静态方法只能使用静态的成员变量

非静态的方法可以使用静态的成员变量。 可直接使用类名访问。

静态方法不能用this和super

代码块（一个没有名字的代码块）
实例代码块：在每次创建对象执行

静态代码块：类被加载时自动执行

public class Demo {
    {
        System.out.println("林青霞");
    }（实例代码块）
​
    static  {
        System.out.println("张曼玉2");
    }（静态代码块）
​
}
public class Teatdemo {
    public static void main(String[] args) {
        new Demo();
}
}
包
作用： 在Java中用包管理类

作用：避免类重名 控制访问权限（在不同包中，对不同权限的成员）

目前至少三级

第一级 项目类型 com org gov edu

第二级 公司名字 baidu sun

第三级 项目名字 oa erp

第四级 功能模块

访问权限修饰符
可修饰类，成员变量，成员方法，内部类（公共，受保护，默认，私人都可修饰）

public（公共权限）在任何地方都可访问，本类，本包其他类，其他包中的类

protected(受保护) 本类 ，本包其他类可访问，还可在其他包的类中访问

private（私人）只能在同类中访问本类，同包其他类中可以访问

默认权限：

面向对象语言的三大特征
封装
一般意义的封装 例如将重复出现的代码抽取一个函数，即为代码的封装。

面向对象语言的封装

将类中的某些信息使用不同的权限修饰符隐藏起来不让外部直接操作而是通过类向外提供特定的方法去访问操作，方便加入控制语句，主动权在类自己手中

类中方法私有化

单例模式：让一个类在一个程序中只能创建一个对象

变量分类

按位置分

成员变量：在类中定义 可以使用权限修饰符 ，在构造方法中自动进行初始化赋值

生命周期

：非静态：随着对象的销毁而销毁，创建而创建

静态: 随类的加载而加载，随类的销毁而销毁

存储位置 ：

非静态 ：堆

静态 ： 方法区

局部变量：定义在方法，或者是参数中 不可以使用权限修饰符

必须自主初始化

继承
将同一类事物中共性的属性和行为进行抽取，定义在一个类中（基类）其他类可以继承基类，拥有基类的功能 实现代码的复用性以及在子类中扩展自己的功能而不影响其他类。（只要是符合iS—a）就使用继承

特点：减少冗余提高代码的复用性

一个类只能直接继承一个类间接继承多个类，具有一定的传递性。

子类继承父类，拥有父类的成员变量，成员方法，不能直接访问父类的私有成员。

​
public class Employee extends Person {
    private int employeeId;
 
    public Employee(String name, int age, int employeeId) {
        super(name, age);
        this.employeeId = employeeId;
    }
 
    public void work() {
        System.out.println("Employee is working");
    }
}

​

 

当一个类没有显示的继承则该类默认继承object类（Java体系中最大的，object之上再无其他类）

方法重写
当父类方法实现不能满足子类需求时，可以在子类中对父类方法进行覆盖。

要求：子类重写的结构与父类的结构一致。方法名参数列表，返回值必须一致。父类私有权限不能重写

@override 注解标签表示此方法是父类重写来的。重写方法结构与父类方法一致，也算正确重写。

建议保留 1.编译器进行语言验证，2.阅读时明确方法是重写的。

方法重载 方法名相同，参数不同（数量，顺序，类型）

public class Animal {
    public void makeSound() {
        System.out.println("Animal sound");
    }
}
 
public class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Bark");
    }
}

super
在子类中调用父类中的成员，构造方法

注意 super和this的用法相像，this表示当前对象，但super表示父类成员而不是父类对象。

继承中的构造方法：在创建子类对象

抽象
抽象方法（没有方法体，用abstract修饰）;一种特殊方法,只有声明没有具体的实现的方法

在一些体系结构顶端类，有些功能没必要实现因为子类实现都不同，此时可将方法声明为抽象方法。

类中包含抽象方法必是抽象类，抽象类不一定包含抽象方法。抽象类可能包含抽象方法，抽象方法不完整所以类也是抽象。

特点：

1.抽象类不能被创建对象，其他功能与正常类相同，也可以有成员变量，成员方法，构造方法

2.主要在上层定义功能，在子类继承实现

多态（同种事物在不同时刻表现不同状态）也称为向上转型
父类的引用变量，指向子类对象（必须要有继承关系）

优点：可以提高程序的扩展

缺点：一旦转为父类类型就不能调用子类中有方法 可以向下强制转换可参考引用类型强制转换

不同时期：

编译：类型是父类 运行：为子类

多态语法

成员方法：编译看左边 运行看右边

静态成员方法 ：编译运行都看左边

成员变量：编译运行都看左边

将子类类型转换父类类型就不能调用子类特有方法 解决：将父类转换为子类

父类 instanceof 具体子类类型（表示父类中持有实际类型是否为指定类型）

final
用于修饰类，方法，参数，成员变量（常量）

接口（一种特殊的抽象类，可以包含抽象方法）
是计算机领域的名词，表示功能的定义例如USB接口定义

接口不能被创建对象被其他类实现，重写抽象方法

定义

类通过implements 关键字实现接口

一个类可以继承一个类，一个类可以继承多个接口，一个接口可以多个接口

接口和类之间存在多态性

API常用类

指官方为开发人员所提供的开发说明文档

后面Java学习就是学习Java语言提供哪些类，在这些类的基础上进行开发提高开发效率。

Object类
Java.lang.Object 是Java类体系中根基类 ，可以表示Java中任意的类

自己可以Object类的toString

Object

toString：将信息以字符串的形式输出。

boolean equals (Object obj) 判断两个对象是否相等

Object类中的equals 默认是比较两队像的地址是否相等可用==代替

在其他类中一般重写equals（），将他改造成比较两对象是否相等

equals()重写：

public  boolean equals(Object obj){
​
    if(obj instanceof Object){
        Person other=(Person)obj;
        return  this.name.equals(other.name)&&this.age==other.age;
​
    }
    return  false;
}
== :比较等号两边是否相等，用于引用类性，比较的是对象的地址 用于基本类型 ，是比较对象是否相等

Arrays类
copyOf 数组复制

sort()对指定数组进行升序排列

我们一个类要进行排序，这个类需要实现comparable接口，指定一个排序方法

基本数据类型包装类 Java中基本数据类型使用8个关键字声明不是面向对象 Java语言是面向对象可以为每个基本类型进行定义

自动拆箱：将引用类型转换基本类型，自动默认调用intValue（）；方法

自动装箱：将基本类型转换为引用类型

默认调用valueOf()方法；在valueOf()中如果基本类型的值在-128-127之间会从缓存数中直接去除Integer对象，减少创建次数，如果两个值不在缓存区每次都创建一个Integer返回
public static Integer valueOf(int i) {
        if (i >= IntegerCache.low && i <= IntegerCache.high)
            return IntegerCache.cache[i + (-IntegerCache.low)];
        return new Integer(i);
    }
String
int length() 获取字符串长度
char charAt(int index) 获取指定字符
itn indexOf(String str)  指定字符首次出现的位置
  int lastindexOf() 从后向前找指定字符首次出现位置
  String substring(int start)  从指定位置截取字符字串
  String substing(int start ,int end) 从指定位置截取字符字串，到指定位置不包含结束位置String Str= "123";       创建时先去字符常量池中查找，有没有相同值得对象 ，没有就从创建一个字符对象
String str =new String("123"); 每次则要创建新对象

正则表达式（简称regx）
是一种规则匹配语法，可以使用一些正则表达式中定义特殊符号来定义一种规则，然后用此匹配某些字符串 匹配则ture.否则为false,

math
java.lang.Math提供了一系列静态方法用于科学计算；其方法的参数和返回值类型一般为double型
 
abs 绝对值
 
sqrt 平方根
 
pow(double a, double b) a的b次幂
 
max(double a, double b)
 
min(double a, double b)
 
random() 返回 0.0 到 1.0 的随机数
 
long round(double a) double型的数据a转换为long型（四舍五入）
StringBuffer 
package JavaApi.Str4;
 
public class StringBuffer1 {
    public static void main(String[] args) {
        /*
        string声明的字符串对象值一旦给定就不能改变，每次拼接都会创建新的字符串对象，好事占空间
        StringBuffer是内容可变字符串
          char[] value; 没有final修饰，每次添加内容都是对此数组进行操作，不会创建新的字符串对像
         */
        StringBuffer S1=new StringBuffer("acbd");//创建内容长度+16的char数组
       // StringBuffer S1=new StringBuffer();//空参构造方法，指定底层数组长的为16
        StringBuffer s=new StringBuffer(10);//指定数组容量
        S1.append("12");
        S1.insert(1,5);//向指定位置插入指定数字、
        S1.insert(1,"C");
        System.out.println(S1);
        S1.deleteCharAt(0);//删除指定位置的字符
        System.out.println(S1);
        StringBuffer s2=new StringBuffer("abdefgrt");
        s2.reverse();//逆序
        s2.delete(0,3);//删除指定区间的元素，包括开头，不败含结尾
        System.out.println(s2);
    }
 
 
}

String : 值不能改变的字符串
StringBuffer:值可以改变且不需要创建新队象，方法上都加上锁在多线程执行是安全
StringBuider:值可以改变且不需要创建新队象，方法上没加上锁在线程执行是不安全，适合单线程
基本数据类型包装类
java中的基本数据类型使用八个关键字声明的，不是面向对象。

java语言是面向对象的，可以为每个基本类型定义一个类来进行表示，这样我们在类中还是保持有一个基本类型变量存储数据，同时还可以提供许多方法对变量进行操作(将十进制转化为二进制)

Integer
构造Integer对象，里面包着一个基本数据类型值，用该对象表示一个这个值

 
 
package Javaapi.Basedemo;
 
public class Integers {
    public static void main(String[] args) {
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
        Integer a=new Integer(18);
        Integer b=new Integer("10");
        System.out.println(a);
        System.out.println(b);
       //一类为静态方法 System.out.println(Integer.toBinaryString(10));
        System.out.println(Integer.toHexString(17));
        System.out.println(Integer.toOctalString(9));
    }
    System.out.println(Integer.compare(8,10));//可用来比较大小。返回0，1，-1，表示大小
    
    //一类是非静态
    System.out.println(a.equals(b));
    System.out.println(a.compare(b));
   //转换的方法   包装类型转换为基本类型 
    int aa=a.intValue();
    int bb=Integer.parseInt("20");
    //把基本类型转换为包装类型
    int cc=10;
    Integer dd=new Integer(cc);
    Integer ee =Integer.valueof(cc);
    }

集合

数组特点 存储数据类型相同的元素集合 ，创建前给定长度且一旦创建长度不变，满员后，要重新创建，将元素复制过去。缺点 删除，添加则要移动元素。

Java为解决数据存储单一情况，提供许多不同结构的集合类，让我们可以根据不同场景进行数据存储选择，让使用起来更加方便

集合容器中默认可以添加Object类 习惯在集合类型只保存一种类型，保存多个类型，会涉及到类型转换

泛型：在声明式自定义参数类型

单列集合：一次放进一个值或对象

Collection ：定义单链接口的所有方法

list:可以重复

set:不可重复

双链 ： 键，值，

list:可以重复
arrarylist:数组列表，底层有一个数组，可以动态扩展数组长度，查询快，添加删除慢并提供一个一些列的方法操作

import java.util.ArrayList;
​
public class Deno1 {
    public static void main(String[] args) {
        ArrayList arr=new ArrayList();
        arr.add("q");
        arr.add("1");
        arr.add("cb");
        arr.remove("1");
        System.out.println(arr);
        ArrayList ar=new ArrayList();
        ar.add("123");
        ar.add("abc");
        ar.add("456");
        ar.add("123");
        ar.add("789");
        ar.remove("123");//根据内容，匹配的第一个元素成功ture
        ar.remove(0);//删除并返回指定位置的元素
        System.out.println(ar);
        System.out.println(ar.get(1));//获取指定位置的元素
        System.out.println(ar.set(2,"156"));//替换并返回指定位置的元素
        /*
        add(E e)
            public boolean add(E e) {
               ensureCapacityInternal(size + 1);  //检测元素是否放下
                elementData[size++] = e;
                  return true;
                }
           add(0,"e")在指定位置添加元素
         */
        ArrayList<Integer>arr1=new ArrayList();
        arr1.add(1);
        arr1.add(2);
        arr1.add(3);
        arr1.add(4);
        arr1.add(4);
        System.out.println(arr1);
        System.out.println(arr1.isEmpty());//判断是否为空
        System.out.println(arr1.set(2,6));
        System.out.println(arr1.size());
        System.out.println(arr1.indexOf(4));
        System.out.println(arr1.lastIndexOf(4));
​
    }
}

linklist:链表列表，底层是一个链表，查询慢，添加删除快

li.add("abcdefght");//向链表末尾添加
li.add(1, "g");//向指定位置插入
// System.out.println(li.get(2));
System.out.println(li.remove());//删除并返回第一个
System.out.println(li.removeFirst());//删除并返回第一个
list接口集合迭代遍历
ist接口实现类 /遍历方式 for循环 允许操作元素注意索引的变化与元素位置的移动
         for(int i=0;i<ar.size();i++){
          System.out.println(ar.get(i));
         }
         2.增强for循环 遍历元素时不允许修改元素（删除，增加）
​
     */
   for(String s:ar){
​
       System.out.println(ar);
   }
    Iterator<String> it =ar.iterator();//list迭代器  获得集合的迭代对象
     while(it.hasNext()){
         String s=it.next();
         if(s.equals("a")){
             it.remove();
         }
     }
    System.out.println(ar);
    ListIterator<String> listIterator=ar.listIterator();//listIterator
    while(listIterator.hasPrevious()){
        System.out.println(listIterator.hasPrevious());
    }
}

Vector:

Set接口（继承Collection接口）
HashSet ：元素无序，不能添加重复元素

Treeset：元素按照一定顺序排列不能重复存储元素，底层使用树结构

set:元素不重复

set:元素时不重复
Hashset:元素无序
HashSet:在添加元素时如何判断元素重复的。向集合添加元素时每次比较equals()比较内容效率低，
调用Hashcode（）---Object中的hashcode（）返回的是对象地址（不调用这个）
会调用类中重写的hashode()返回的是根据内容计算的哈希值，遍历时会用hash 值先比较啊hi发相等提高比较
效率，可能存在内容不同，哈希值相同，此情况下再强调equals（）比较内容，这ji提高效率又保证安全
Map接口
键映射到值的对象，键最多映射到一个值，一个映射不能包含重复的值

HashMap
键是无序的

可以存储一个建为null，值为null的元素

底层使用一个长度默认为16的数组，用来确认元素的位置，每次用key计算出哈希值，用哈希值%数组长度确定元素位置，将元素放在哈希表中指定的位置

后来继续添加元素，如果出现相同位置且不重复的元素，那么将后来的元素添加到之前的元素的next节点

当链表长度大于64时链表才会转为红黑树

哈希表负载因子为0.75，当哈希表使用数组的0.75时，会自动扩容为原来数组长度的2倍

treemap

键可以排序

键元素类型必须实现Comparable接口，重写compareTo()。

hashtable

实现了同步

方法上都添加了synchronized锁

Hashtable中不能存在null的键和null的键值

package Map;
 

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
 
public class HashMapDemo {
    public static void main(String[] args) {
        HashMap<String, String> hashMap = new HashMap<>();
        /*
        HashMap 底层数据结构
            哈希表
        static final int hash(Object key)
        {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
            }
          Map 数据存储是键：值的形式存储
          键不能重复，值可以重复
          一个键只能映射到一个值
          HashMap：
            键是无序
         */
        hashMap.put("q", "we");//hashmap 中添加一组键，值对
        hashMap.put("t", "yu");
        hashMap.put("o", "po");
        hashMap.put("q", "aaa");
        hashMap.put("v", "lo");
        //hashMap.clear();//清空hashmap
        System.out.println(hashMap);
        System.out.println(hashMap.remove("t"));//删除指定键值，返回对应值
        System.out.println(hashMap.isEmpty());//判断键值对的个数是否为空
        System.out.println(hashMap.size());//hashmap的大小
        System.out.println(hashMap.get("o"));//获取键值
        /*map遍历
        1先拿到所有的键，遍历键，根据键找值
         */
        Set<String> keyset = hashMap.keySet();
        for (String ke : hashMap.keySet()) {
            System.out.println(ke);
        }
        //方法2
        Set<Map.Entry<String, String>> entries = hashMap.entrySet();
        for (Map.Entry en : entries) {
            System.out.println(en.getKey() + ":" + en.getValue());
        }
 
    }
}

 

泛型
 

public class Genericity<A> {
        /*
            关于为什么要使用泛型？
                -有的时候不知道要用什么传入什么参数，同时又需要不断地进行父类子类的转化，太过于麻烦，所以有了这个东西
         */
 
        A[] objects = (A[])new Object[30];//强制类型转换
 
 
        //<A>可以是任意标识符,也可以定义多个泛型(键值对)
 
    public void add(A obj){
        //形参类型也是由外部定义的
    }
 
    public A get(){
        //返回值也是由外部指定
        return null;
    }
 
    public static void main(String[] args) {
        //在存储方面有些优势，任何类型的数据都可以存储，但是缺点在于不好取出
 
        //定义<A>之后，这里所有类型都可以通过A来替换
 
        /*
            在定义时，为类指定类型，在编译期间添加数据时进行类型的校验
            -传参时只能用类来传递类型(integer),不能用基本数据类型(int)来传递
            -泛型的类型参数可以有多个
            -没有指定默认为object
         */
 
        Genericity<String> genericity1=new Genericity<>();//变量类型由外部指定
        genericity1.add("");
        //返回值为String
        genericity1.get();
        //同理也可以使用Integer
        Genericity<Integer> genericity2=new Genericity<>();
        genericity2.add(213);//传入的实参类型需要与泛型的参数类型相同
        //返回值为Integer
        genericity2.get();
    }
 
 
    A name;
 
}