JAVA初学2-博观而约取（异常类，常用类，容器，泛型）

 一：类与对象的基础概念：

类：把具有相同的属性和行为的一类对象抽象为类.

对象：某个类的一个实体

类是描述某一个对象的统称，对象是这个类的一个实例

class person
{
    成员变量/实例变量;
     成员方法;
}

2.创建具体的对象

类名称 引用名称=new 类名称()；

Person per=new Person();//相当于给对象起个名字.

3.（创建一个Person类的对象）

public class test2 {
    public static void main(String[] args) {
         Person per1=new Person();
         per1.name="小韩";
         per.age="18";
         per.sex="女";
         per.print();
         Person per2=new Person();
         per2.print();
    }
}
class Person{
    String name ;
    int age;
    String sex;
    void eat(String food)
    {
        System.out.println(name+"喜欢吃"+food);
    }
    void print(){
        System.out.println("name"+name+", age"+age+", sex"+sex);
    }

4.static关键字：

static修饰属性（类属性，类变量）

1当一个实例变量被static关键字修饰后，它就表示类的属性。

对三大特性的再认识：

1.访问修饰符：

private(私有的)：被它修饰的方法只能在当前类可见，外部不知道有其存在

default(不需要写关键字)：

protected(继承访问权限)

public(公开的)，被其修饰的，在当前项目中都是可见而且是可以使用的。

public class test2{
    public static void main(String[] args) {
        Bank bank=new bank();
        bank.setPassword();
        System.out.println("密码");
        System.out.println(bank.getPassword());
        System.out.println("卡号");
        System.out.println(bank.getCardNum());
        System.out.println("余额");
        System.out.println(bank.getBalance);
    }
}
class Bank{
    private int cardNum;
    private double balance;
    private String password="123456";

    public int getCardNum() {
        return cardNum;
    }
    public double getBalance() {
        return balance;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword() {
        Scanner scan = new Scanner(System.in);
        int count = 0;
        while (true) {
            System.out.println("输入新的密码");
            String oldPass = scan.nextLine();
            count++;
            if (oldPass.equals(password)) {
                System.out.println("验证成功，输入新的密码");
                String newpass = scan.nextline();
                password = newPass;
                System.out.println("密码修改成功");
                break;
            } else {
                System.out.println("密码错误，请再次输入");
                if (count == 3) {
                    System.out.println("次数太多，卡已经被锁定");
                    break;
                }
            }
        }
    }
}

static修饰的属性，直接通过类名称就可以访问，无需通过变量

注意：private class Person{

}只是不允许的，private不能用来修饰一个类

构造方法：在一个新类中进行构造。

pulbic class Test2{
    public static void main(String[] args) {
        Person person=new Person();
    }
}
class Person{
    String name;
    int age;
    String sex;
    pulbic Person()
    {
        System.out.println("这个是Person的构造方法");
    }
}

this关键字：表示对当前对象的使用

this关键字调用当前对象的成员变量

public class Test {
    public static void main(String[] args) {
        //当构造对象时，默认调用该类的构造方法
        Person person = new Person();
        Person person1 = new Person("小韩");
        Person person2 = new Person("小韩",18);
        Person person3 = new Person("小韩",18,"女");
    }
}
class Person{
    String name;
    int age;
    String sex;
    public Person(){
//构造方法首行name = null,age = 0;sex = null（不用写）
        System.out.println("Person类的无参构造");
    }
    public Person(String n){
//首行name = null,age = 0;sex = null;
        name = n ;
        System.out.println("name:"+name);
        System.out.println("Person类的一个参数的有参构造");
    }
    public Person(String n,int a){
        name = n ;
        age = a;
        System.out.println("name:"+name+", age:"+ age );
        System.out.println("Person类的两个参数的有参构造");
    }
    public Person(String n,int a,String s){
        name = n ;
        age = a;
        sex = s;
        System.out.println("name:"+name+", age:"+ age +", sex :"+sex);
        System.out.println("Person类的三个参数的有参构造");
    }
}

上面的代码只会输出null，0，null，因为形参名称和成员变量名称相同，而进行了就近规则，没有从类中去找变量

所以，我们要使用this关键字，来调用当前对象的方法

class Person{
    String name;//实参
    int age;//实参
    String sex;//实参
    public Person(String name,int age,String sex)//形参，表示这个方法中定义了name，age,sex等变量
    {
     this.name=name;//这个就代表class Person类中的name,age,sex;
     this.age=age;
     this.sex=sex;
     System.out.println("这是Person类的有参构造");
    }
}

[点击并拖拽以移动]
​

这时的this就可以把age，name，sex等和前面的class Person中定义的实参结合起来，从而实现调用的可行化

言归正传：JAVA异常类和常用类，容器，泛型

一：异常类：

1：概念：

异常是程序运行中出现的一些错误，java提供了优秀的解决方案：异常处理机制。

在Java中对于错误和异常的处理是不同的，我们可以从异常中恢复程序但却不应该尝试从错误中恢复程序。

ClassNotFoundException的产生原因：

java异常的可能性

1.函数中的语句执行时引发的.

2：程序员通过throw语句手动抛出的

解决方法：用一个对应的异常对象来封装异常，JRE就会寻找异常程序来处理异常

2.分类：Throwable类是javai异常类型的顶层父类，一个对象只有Throwable类的实例；

他才是一个异常对象，才能被异常机制识别，JDK中建一些常用的异常类，我们将其定义为自定义异常

Error：错误不可预料；

Exception：较常见。可以预料

一些错误的标识（代码写的有问题）：

除0错误-ArithmeticException;

错误的强制类型转换错误：ClassCastException

数组索引越界：ArrayIndexOutOfBoundsException

使用空对象：NullPointerException

（编译环境有问题）:

SQLE ception数据库异常

IOE ception输入或输出异常

ClassNotFoundException类名书写错误，出现异常

3.异常处理的基本语法：

一：捕捉：try-catch（在方法体内）

try{
 //可能出现异常的代码
}catch(Excption e)
{
    //针对异常出现后，要进行的操作
}
finally{
   //一定会执行的代码：例如关闭同步流，数据库连接
}

二：抛出throws（不会）

2.常用类：

String 类

程序可以直接使用string，string没有子类。

public int length()//获取string对象的长度
public boolean equals(String s)//两个字符序列是否相同
public boolean startsWith(String s)//当前对象序列前缀是否是s指定对象的字符序列
public boolean endsWith(String s)//当前对象后缀是否与s指定的字符序列相同
public int compareTo(String s)//按字典序与参数s指定对象比大小，相同0，大于s返回正值，小于s返回负值
public boolean contains(String s)//当前对象字符序列是否包含参数s的序列
public int indexOf(String s)//当前对象序列从0开始检索，如果有，返回位置，否则输出-1；
public int lastIndexOf(String s)//当前对象序列从0开始检索，找到最后一次出现s序列的位置，返回该位置，否则返回-1
public String substring(int startpoint)//

StringTokenizer类

StringTokenizer(String s)
StringTokenizer(String s,String delim)
//以下是示例
StringTokenizer fenxi=new StringTokenizer("you are welcome");
StringTokenizer fenxi=new StringTokenizer("you#*are#*welcome#*","#*");

Scanner类

Scanner对象可以调用方法

useDelimiter(正则表示式);

Scanner scaner=new Scanner(cost);
Scanner.useDelimiter("[1234567.]+");

StringButter类

与String类不同，StringBuffer类的对象的实体的内存空间可以自动改变大小，便于存放一个可变的序列。

StringBuffer s=new StringBuffer("我喜欢");
s.append("干饭");//这个就是追加字符--我喜欢干饭

Date类与Calendar类

~Date类：可以获得本机的当前日期与时间

~Canlendar类：使用该类的static方法getInstance()可以初始化一个日历对象

Math类，BigInteger类，Random类

~Math类

public static long abs(double a)//绝对值
public static double max(double a,double b)//return 最大值
public  static double min(double a,double b)//return 最小值
public static double random()//产生一个0~1的随机数，但是不包含0和1;
public static double pow(double a,double b)//a的b次幂
public static double sqrt(double a)//a的平方根
public static double log(double a)//a的对数
public static double sin(double a)//sin
public static double asin(double a)//反sin
public static double ceil(double a)//return 大于a的最小整数
public static double floor(double a)//返回小于a的最小整数
public static long round (double a)//return (long)Math.floor(a+0.5)//四舍五入
    

~BigInteger类

用于处理一些特别大的整数，public BigInteger(String val)来构建一个十进制的BigInteger对象

~Random类

创建出一个随机数生成器

Random random = new Random();
int randomNumber1= random.nextInt(100);

Random random1 = new Random(100);
for(int i = 0; i < 10; i++){
    System.out.print(random1.nextInt(10) + " ");
}

class类与Console类

Class类就是帮助创建其他类的实例

Console类：如果希望在键盘出入一行文本，但不想让该文本回显，也就是不在命令行显示--那麽需要Console类的对象来完成

Console cons =System.console();//首先调用System类调用console()方法返回Console类的一个对象，cons
char [] passwd=cons.readPasswd;//然后，cons调用readPasswd()方法读取用户输入的一行文本，并将文本以一个char数组返回

Pattern类和Matcher类

String input="hello good morning,let's go to school,that is a good idea";
String regex="good";//前两行的目的是找到input序列从那个字符开始到那个字符结束中有字符good
Pattern pattern=Pattern.compile(regex);
Wather matcher=pattern.macher(input);//固定模式

JAVA容器 

因为int型数组，或者是char数组都需要我们在一开始就指定它的大小，而一般来说，我们不能确定它的大小是多少---并且对于数组而言，添加，删除，插入数据又不便利，所以我们引用Java容器的概念

Java分成两个大类：Collection和Map两个类

Collection代表集合***类似数组

Map类代表映射***

现在来看看List，Quene，Set，Map这四个的区别。

List~~有序可重复

Set~~无序不可重复

Quene~~队列，所以是按照特定的顺序存储

Map~~使用键值对（key-value）存储y=f(x)，“x”代表key，“y”代表value，key是无序，不可重复的，value是无序，可重复的。

List

ArrayList 数组

Vector 数组

LinkedList 双向链表

Set

HashSet  底层是HashMap(数组+链表)

LinkedHashSet 底层是链表和哈希表

TreeSet 红黑树

以下就是TreeSet的自然排序的部分

package TreeSet;
public class Person implements comparable{
    private int age;
     private String name;
     private int score;
     public Person(int age,String name,int score)
     {
         this.age=age;
         this.name=name;
         this.score=score;
     }
     public int compareTo(Object o)
     {
         if(o instanceof Person)
         {
             Person 0=(Person)o;//强制类型转换
             if(this.age!=0.age)
                 return this.age-0.age;//返回程序值
             else return 0.score-this.score;
         }
         else throw new RuntimeException("不属于该类型");
     }

    public String toString() {
        return"Person"+
                "age=" + age +
                ",name="+name+""+
                ",score="+score+
                '}';
    }
}
package TreeSet
import java.util.Arrays;
public class test2{
    public static void main(String[] args) {
        Person[] person=new Person[3];
        person[0]=new Person(5,"小王",99);
        person[1]=new Person(10,"小张",98);
        person[2]=new Person(13,"小李",97);
        Array.sort(person);
        for(int i=0;i<3;i++)
        {
            System.out.println(person[i].toString());
        }
    }
}

还有定制排序，将已经传入的东西传入到Copaarator方法中

public class Test{
    public static void main(String[] args) {
        Person[] person=new Peerson[3];
        person[0]=new Person(5,"luna",99);
        person[1]=new Person(10,"zrl",98);
        person[2]=new Person(11,"刘一卜",98);
        Coparator com=new Copartor() {
            public int compare(Object o1, Objject o2) {
                Person p1 = (Person) o1;
                Person p2 = (Person) o2;
                return p1.getAge() - p2.getAge();//确保有get和set的接口
            }
        };//一眼就是重写
                Array.sort(person,com);
                for(int i=0;i<3;i++)
                {
                    System.out.println(person[i].toString);
                }
            }
        }

3.Quene

quene：单向队列

deque：双向队列

2.Map 数组加链表

HashMap：线程不安全

LinkedHashMap：线程不安全

ConcurrentHashMap：线程安全

HashTable：线程安全

TreeMap：线程安全（红黑树）

4.将集合转化为数组：

如果指定的数组能够容纳coll，并有剩余空间，那么数组中紧接着coll尾部的那个元素会被设置为null，也就是说多的部分变为null，而前面全部接收

Collection coll=new ArrayList();
Object arr[]=coll.toArray();
for(int i=0;i<arr.length;i++)
        {
        System.out.println(arr[i]);
        }

将数组转化为集合：String类也要写

//asList后面还要加引用的类型
List<String>list =Arrays.asList(new String[]{"AA","BB","CC"});
System.out.println(list);

三.泛型-是为了"忘记"重写

public int multint(int x,int y)
        {
            return x*y;
        }
public float multfloat(int x,int y)
        {
            return x*y;
        }

上面这个式子只有数据类型不同，其他基本相同，但是我们还要再写一遍~~因为参数不同，而泛型就可以自动运算一段代码---（它们只有传入的参数不同，而逻辑基本相同）

泛型的好处：在编码的过程中，可以指定数据类型，不需要进行强制类型转换以及

如果我们插入的数据类型，在编译期间就能够发现，不需要在运行的时候才抛出--类异常

示例：

我们声明一个List集合

而不带任何的类型声明，也就说List属于Object类，而Object类是所有类的父类，所以不同类型的数据添加到List中没有问题，但是从List中取数据的时候，取到的所有数据都是Object，所以再去这些数据的时候需要我们强制类型转换，如·代码中写的是String型，也就需要强制转化为String型，

但是由于List还添加了Interger类型的数据，这时候就会报错--“ClassCastExcpetion”（类转换异常）--

这个是会类报错的

public static void main(String[]args){
        List list=new ArrayList();
        list.add("mark");
        list.add("OK");
        list.add(new Integer(100));
        for(int i=0;i<list.size();i++)
        {
          String name=(String)list.get(i);//这里需要强制类型转换
          System.out.println("name"+name);
        }
}

在使用完泛型后就适用于多种数据结构

下面的一个程序就是保持一致后的结果：

​
public static void main(String[]args){
        ArrayList<String> array=new ArrayList<String>();//这就是泛型的写法
        //添加一些元素
        array.add("xiao");
        array.add("huang");
        array.add("mao");
        Iterator<String>it=array.iterator();
//Iterator接口的实现类的对象，it是它的实现类；array代表数组，而coll代表集合
        while(it.hasNext())//hasNext()的返回值是bool值，也就是0或1来决定while循环
        {
//it是迭代器Iterator对象，it.next()表示下一个对象，也就是遍历寻找
            String s=it.next;
            System.out.println(s);
        }
}

​

​

​

2.什么是泛型：一种约束规范的类型（E=Element,T=Type,K=Key,V=Value）

​
public class Student{
    private String name;
    private int age;
    public Student(String name,int age)//没懂
    {
        super();
    }
    public Student(string name,int age)
    {
        super();
        this.name=name;
        this.age=age;
    }
public String getName()
{
    return name;
}
public void setName(String name)
{
    this.name=name;
}
public void getAge()
{
    return age;
}
public void setAge(int age)
{
    this.age=age;
}
public String tostring()
{
    return "Student[name="+name+", age="+age+"]";
}
}

​

public static void main(String[] args) {
        ArrayList<Stduent> array = new ArrayList<Student>();
        Student s1 = new Student("张睿霖", 18);
        Student s2 = new Student("wyy", 19);
        Student s3 = new Student("zxy", 19);
        array.add(s1);
        array.add(s2);
        array.add(s3);
        //迭代器
        Iterator<Student> it = array.iterator();
        whille(it.hasNext())//上文有
        {
            Student s = it.next();
            System.out.println(s.getName() + "   " + s.getAge());
        }
        for (int i = 0; i < array.size(); x++) {
            Student s = array.get(x);//这个for循环将get(int index)与size()相结合
            System.out.println(s.getName() + "   " + s.getAge());
        }
}    

泛型的应用：

泛型主要集中在集合中：

1.定义在类中（class-private,public,protected）

2.定义在接口中（interface）

3.定义在方法中（一会看）

定义在类中:

第一步：先在一个类上定义泛型

​//使用泛型，将泛型定义在类上
public class ObjectTool<T> {
    private T obj;
    public T get() {
        return obj;
    }
    public void set(T obj) {
        this.obj = obj;
    }
}

​

第二步：将泛型定义在测试类上，就不用定义char,int,float等等

 
public static void main(String[] args) {
        ObjectTool<String> ot=new ObjectTool<String>();
        ot.set("阳光开朗的女孩");
        String s=ot.get();
        System.out.println("评价是"+s);
        ObjectTool<Integer> ot2=new ObjectTool<Integer>();
        ot2.set(18);
        Integer i=ot2.get();
        System.out.println("年龄是"+i);
    }

定义在接口上：

格式：

public interface Inter<T>{ public abatract void show(T t);}

~~1. 实现类已经明确数据类型

/*测试类*/
public class InterDemo
{
   public static void main(String[],args)
      {   Inter i=new InterImpl();
          i.show("阳光开朗的女孩");
      }
}

​
//接口子实现类
public class InterImpl implements Inter<String>
{
    public void show(String t)
    {
        System.out.println(t);
    }
}

​

~~2. 子实现类没有明确数据类型

/*定义在接口上*/
public interface Inter<T>
{
    private abstract void show(T,t);
}

/*测试类*/
public class InterDemo{
    public static void main(String[] args) {
        Inter<Integer> i1=new Inter<Integer>();
        i1.show(100);
        Inter<Integer> i2=new Inter<String>() 
        i2.show("阳光开朗的女孩");
    }
}

三.定义在方法上：

格式：public<泛型类型>返回类型  方法名(泛型类型)

public class ObjectTool<T>
{
    private <T> void show(T,t)
    {
        System.out.println(t);
    }
}

​
 public static void main(String[] args) {
        ObjectTool ot =new ObjectTool();//创建ObjectTool的对象，show方法
        ot.show("Hello");
        ot.show(ture);
        ot.show(12);
        ot.show(12.34);
}

​