这里写目录标题

• • 子类中所有的构造方法都会访问父类中无参的构造方法
  • 在没有含参含参构造方法的情况下，系统会自动补充一个无参构造方法，若已经有了含参构造方法，则需要特别加上一个无参构造方法
  • 导包
  • 当一个包外子类继承保护成员时，该成员在这个子类内实际上变为私有。
  • 权限符
  • final关键字
  • final 与 static 的区别
  • 多态的优点和弊端
  • int型转换成string类型的方法
  • string转化为int型
  • 数组.split(xxx)
  • stringBuilder和stringBuffer的区别和方法
  • 作用是什么？为什么要进行拆箱和装箱？以及装箱和拆箱的方法
  • 异常概述
  • try catch
  • Java throws和throw：声明和抛出异常
  • String方法大全
  • 自定义异常类

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

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

有时可以这样做：当父类是一个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)