java期末复习

子类中所有的构造方法都会访问父类中无参的构造方法

在没有含参含参构造方法的情况下，系统会自动补充一个无参构造方法，若已经有了含参构造方法，则需要特别加上一个无参构造方法

有时可以这样做：当父类是一个person类时：

导包

import cn.itcast.类名

当一个包外子类继承保护成员时，该成员在这个子类内实际上变为私有。

protect权限修饰符详解

权限符

final关键字

修饰方法：不能被重写
修饰变量：不能被赋值
修饰类：不能被继承

final 与 static 的区别

static和final的区别

static修饰的变量能被修改

static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会 执行一次。
static调用特点


第一种设置静态变量的方法：

第二种：（推荐）

多态的优点和弊端

匿名内部类
实现方法

接口
抽象类

int型转换成string类型的方法

1.（字符串相加==字符串的连接）

2.valueof方法
value适用于很多种其它类型的变量转化成string的情况

string转化为int型

数组.split(xxx)

String a ={"sadfasdf,sdafsa,dsafsa"};
char []b=s.split(",");

stringBuilder和stringBuffer的区别和方法

链接

作用是什么？为什么要进行拆箱和装箱？以及装箱和拆箱的方法

Java是一种完全面向对象的语言。因此，包括数字、字符、日期、布尔值等等在内的一切，都是对象。似乎只需要一种方式来对待这些对象就可以了。
对于CPU来说，处理一个完整的对象，需要很多的指令，对于内存来说，又需要很多的内存。如果连整数都是对象，那么性能自然很低。
于是创造了这样一种机制，使得这些基本类型在一般的编程中被当作非对象的简单类型处理，在另一些场合，又允许它们被视作是一个对象。
这就是装箱和拆箱。
作用：为了保证通用性和提高系统性能

int到Integer:

int a=3;

Integer A=new Integer(a);

或:

Integer A=Integer.valueOf(a);

Integer到int:

Integer A=new Integer(5);

int a=A.intValue();

异常概述

try catch

捕获异常
使用 try 和 catch 关键字可以捕获异常。如果 try 语句块中发生异常，那么一个相应的异常对象就会被拋出，然后 catch 语句就会依据所拋出异常对象的类型进行捕获，并处理。处理之后，程序会跳过 try 语句块中剩余的语句，转到 catch 语句块后面的第一条语句开始执行。
使用 try/catch 的语法如下：

try
{
   // 程序代码
}catch(ExceptionName e1)
{
   //Catch 块
}

实例
下面的例子中声明有两个元素的一个数组，当代码试图访问数组的第四个元素的时候就会抛出一个异常。

ExcepTest.java 文件代码：

// 文件名 : ExcepTest.java
import java.io.*;
public class ExcepTest{
 
   public static void main(String args[]){
      try{
         int a[] = new int[2];
         System.out.println("Access element three :" + a[3]);
      }catch(ArrayIndexOutOfBoundsException e){
         System.out.println("Exception thrown  :" + e);
      }
      System.out.println("Out of the block");
   }
}

以上代码编译运行输出结果如下：

Exception thrown  :java.lang.ArrayIndexOutOfBoundsException: 3
Out of the block

Java throws和throw：声明和抛出异常

throws 声明异常
当一个方法产生一个它不处理的异常时，那么就需要在该方法的头部声明这个异常，以便将该异常传递到方法的外部进行处理。

使用 throws 声明抛出异常的思路
当前方法不知道如何处理这种类型的异常，该异常应该由向上一级的调用者处理；如果 main 方法也不知道如何处理这种类型的异常，也可以使用 throws 声明抛出异常，该异常将交给 JVM 处理。
throw 拋出异常
throw和throws的区别
自定义的异常想要throw的话必须用throws先抛出

String方法大全

String方法

自定义异常类

可以像下面这样定义自己的异常类：

class MyException extends Exception{
}

自定义一个异常类

InsufficientFundsException.java 文件代码：
文件名InsufficientFundsException.java
import java.io.*;
 
/自定义异常类，继承Exception类
public class InsufficientFundsException extends Exception
{
  /此处的amount用来储存当出现异常（取出钱多于余额时）所缺乏的钱
  private double amount;
  public InsufficientFundsException(double amount)
  {
    this.amount = amount;
  } 
  public double getAmount()
  {
    return amount;
  }
}

抛出异常

// 文件名称 CheckingAccount.java
import java.io.*;
 
/此类模拟银行账户
public class CheckingAccount
{
  /balance为余额，number为卡号
   private double balance;
   private int number;
   public CheckingAccount(int number)
   {
      this.number = number;
   }
  /方法：存钱
   public void deposit(double amount)
   {
      balance += amount;
   }
  /方法：取钱
   public void withdraw(double amount) throws
                              InsufficientFundsException
   {
      if(amount <= balance)
      {
         balance -= amount;
      }
      else
      {
         double needs = amount - balance;
         throw new InsufficientFundsException(needs);
      }
   }
  //方法：返回余额
   public double getBalance()
   {
      return balance;
   }
  //方法：返回卡号
   public int getNumber()
   {
      return number;
   }
}

样例类

//文件名称 BankDemo.java
public class BankDemo
{
   public static void main(String [] args)
   {
      CheckingAccount c = new CheckingAccount(101);
      System.out.println("Depositing $500...");
      c.deposit(500.00);
      try
      {
         System.out.println("\nWithdrawing $100...");
         c.withdraw(100.00);
         System.out.println("\nWithdrawing $600...");
         c.withdraw(600.00);
      }catch(InsufficientFundsException e)
      {
         System.out.println("Sorry, but you are short $"
                                  + e.getAmount());
         e.printStackTrace();
      }
    }
}

编译上面三个文件，并运行程序 BankDemo，得到结果如下所示：

Depositing $500...

Withdrawing $100...

Withdrawing $600...
Sorry, but you are short $200.0
InsufficientFundsException
        at CheckingAccount.withdraw(CheckingAccount.java:25)
        at BankDemo.main(BankDemo.java:13)

集合体系结构：

三种集合的遍历方式

注意：
1.迭代器的并发修改异常

2.增强for循环内部是一个interator迭代器

List集合

特点
可重复，有序
特有方法
（list有但是Collection中没有）

LinkList集合

set集合

特点
1.不包括重复元素，
2.没有带索引的方法，所以不能用普通for循环
3.无序
哈希值
获取哈希值：

HashSet

以hashset为代表的就需要重写equal和hashcode方法（alt+insert）

LInkedHashSet
LinkedHashSet集合特点

treeset

自然排序Comparable的使用
重写comparable方法

MAP集合的创建

 Map<String,String> map=new HashMap<String,String>();

map集合的获取功能：

keyset:获取所有键的集合

valueset：获取所有值的集合

map集合遍历方式：

方式一：

方式二

HashMap存ArrayList：

package hashmap;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

public class hashmap1text {
    public static void main(String[] args) {
        HashMap<String ,ArrayList<student>> sc=new HashMap<String ,ArrayList<student>>();
        student s1=new student("张蔚原",100);
        student s2=new student("张蔚原",100);
        student s3=new student("张蔚原",100);
        student s4=new student("张蔚原",100);
        ArrayList<student> a1=new ArrayList<student>();
        a1.add(s1);
        a1.add(s2);
        ArrayList<student> a2=new ArrayList<student>();
        a2.add(s3);
        a2.add(s4);
        sc.put("第一个",a1);
        sc.put("第二个",a2);
        Set<String> keySet=sc.keySet();
        for(String i:keySet){
            System.out.println(i);
            ArrayList<student> value=sc.get(i);
            for(student j:value){
                System.out.println(j.getName());
                System.out.println(j.getScore());
            }
        }
    }
}

统计字符串中各个字符出现的个数

package shiyan;
import java.util.*;
public class balabala {
    public static void main(String[] args) {
        String array;
        Scanner sc=new Scanner(System.in);
        array=sc.next();
        TreeMap<Character,Integer> hash=new TreeMap<Character, Integer>();


        char[] a=array.toCharArray();
        for(int i=0;i<array.length();i++){
            char key=a[i];
            Integer value =hash.get(key);
            if(value==null){
                hash.put(key,1);
            }
            else{
                value++;
                hash.put(key,value);//别忘了加入此元素
            }
        }
       /* Set<Character> keySet=hash.keySet();
        for(Character j:keySet){
            System.out.println(j+hash.get(j));
        }*/
        StringBuilder sb=new StringBuilder();
        Set<Character> keySet=hash.keySet();
        for(Character key:keySet){
            Integer value =hash.get(key);
            sb.append(key).append("(").append(value).append(")");
        }
        String result=sb.toString();
        System.out.println(result);

    }


}

集合的综合应用

头哥例题

标识符和关键字

标识符命名时，切记不能以数字开头，也不能使用任何 Java 关键字作为标识符，而且不能赋予标识符任何标准的方法名
java区分大小写，所以AA和aa是不同的标识符
例如以下合法与不合法标识符。

合法标识符：date、2011、date、D$date 等。

不合法的标识符：123.com、2com、for、if 等。

父类中private修饰的属性和方法在子类中不被继承（错）

子类继承了父类的所有属性和方法或子类拥有父类的所有属性和方法，只不过父类的私有属性和方法，子类是无法直接访问到的。即只是拥有，但是无法使用。