java初学

1、Scanner类

　　　　1)使用

　　　　　　　　a.导入Scanner类　　improt java.util.Scanner;

　　　　　　　　b.创建Scanner对象　　Scanner input = new Scanner(System.in);

　　　　　　　　c.获取输入数据　　　　int now = input.nextInt();

　　　　2)方法

　　　　　　　　a.String next()　　获取字符串

　　　　　　　　b.Int nextInt()　　获取整形数值

　　　　　　　　c.Double nextDouble()　　获取双精度浮点数

　　　　　　　　d.boolean hasNext()　　有输入返回Ture

2、封装　　　　不直接对成员变量进行赋值和调用

　　　　1)private将成员变量的使用限制，用此修饰符修饰的成员变量只能在本类中使用

　　　　2)构造并引用set()方法来赋值，构造并引用get()方法来提取成员变量值

　　　　3)public void setName(String name){

　　　　　　　　this.name = name;

　　　　　　}　　　　//this.name-->之中的this代表调用此方法的那个对象，不能使用在main方法(static修饰的方法)中

3、static关键字　　-->静态成员先于对象而产生,是属于类的，被该类的所有对象共享

　　　　1)使用方法：-->类名.（变量名或方法名）

　　　　2)静态方法中只能调用静态成员（变量或方法）

　　　　3)不同对象共享同一个静态区域，会被覆盖

4、代码块

　　　　1)局部代码块：生命周期仅在该代码块之中

　　　　2)构造代码块：在成员变量初始化之后，构造方法之前执行

　　　　3)静态代码块：静态代码块只在类加载的时候执行一次，形成静态区域，

　　　　　　　　　　　　执行顺序：静态成员-->静态代码块-->非静态成员变量-->构造代码块-->构造方法

5.继承　　-->class 子类 extends 父类{}　　子类从父类中获取非私有的成员，成为继承

　　　　1)子类可从父类中继承成员变量和成员方法（非私有）

　　　　2)当子类创建对象时，父类的构造方法（无参）首先被调用

　　　　3)super([参数列表]):声明创建父类对象-->super.成员可以调用父类的成员

　　　　　　可以使用super()来强制调用父类的有参构造方法

　　　　4)方法的重写：子类与父类有同名方法，调用子类的方法

6、修饰符

　　　　　　　　同一类　　  -->　　同一包　 -->　　不同包子类-->不同包其他类

public　　-->　　√　　　   -->　　√　　　　-->　　√　　　　-->　　√　　　　　　全部可用

protectid -->　　√　　　　-->　　√　　　　-->　　√　　　　-->　　×　　　　　　同一包或子类

默认　　  -->　　√　　　　-->　　√　　　　-->　　×　　　　-->　　×　　　　　　同一包

private    -->　　√　　　　-->　　×　　　　-->　　×　　　　-->　　×　　　　　　类本身

final关键字修饰的变量是常量，不能被改变

　　　　   修饰的方法在子类中不能被重写

　　　　   修饰的类不能被继承

7、Object类　　-->是所有类的超类，可以直接调用

　　　　1)hashcode方法，返回该对象的哈希值（同一个对象的哈希值相同，不同对象的哈希值不同）

　　　　2)getClass().getName()方法，返回Class名称

　　　　3)toString()方法，return getClass().getName()+'@'+Integar.toHexString(HashCode())

　　　　　　System.out.println()方法自动调用toString()方法

　　　　4)equals()方法，指示其他某个对象是否与此对象相等

　　　　　　System.out.println(Student.equals(Student2));　　返回布尔值

8、多态　　　　Object类是所有类的超类（父类）

　　　　1)　有继承

　　　　　　有方法的重写

　　　　　　父类的引用指向子类的对象

　　　　2）可以调用被子类重写的方法，可以调用父类的方法，不能调用子类特有的方法

　　　　3）用于参数的传递

　　　　　　　　main(){

　　　　　　　　　　dosth.(new Son());

　　　　　　　　　　dosth.(new Daugter());

　　　　　　　　}

　　　　　　　　dosth(Father father){

　　　　　　　　　　father.play();　　　　//传递不同的参数调用不同的子类重写的play方法

　　　　　　　　　}

　　　　4）可以通过强转来调用子类的特有方法

9、抽象类　　　　-->abstract关键字,抽象类不能被实例化（不能new对象）

　　　　1)抽象方法　　-->public abstract void eat();　　没有代码段

　　　　　　子类从父类继承的抽象方法必须进行实现

　　　　2)抽象类引用可以作为参数放入成员方法的参数列表，实际需要的是子类对象

10、接口-->interface 接口名{}　　不同类型的类可以调用接口的共同行为　　与抽象类不同在于抽象类可以定义非抽象方法

　　　　1)接口中的所有方法都是抽象方法，都是Public修饰的抽象方法

　　　　2)implements关键字　　public class SwimMan implements Swimmer{}

　　　　　　　　a.SwimMan类必须实现接口的所有抽象方法

　　　　　　　　b.SwimMan本身成为抽象类　　　　　　　　a,b二选一

　　　　3)类可以实现多个接口（不能多继承）　　public class SwimMan implements Swimmer,Runner{}

　　　　4)类可以同时继承父类和实现接口

　　　　5）接口中可以定义成员变量，并可以被实现该接口的类引用，但是默认为public，final，static类型，不能被改变

11、内部类

　　　　1）成员内部类　　-->定义在类的内部

　　　　　　引用方法：a.在类内定义一个对象，作为成员变量引用

　　　　　　　　　　　　b.用法写在类的成员方法里，调用该成员方法

　　　　　　　　　　　　c. 内部类名 对象名 = new 类名().new 内部类名()

　　　　2）静态内部类

　　　　3）局部内部类　　-->定义在成员方法里

　　　　4）匿名内部类　　-->当对象只用一次时直接new完引用就行了，创建匿名内部类

　　　　　　　　new 类名(){

　　　　　　　　　　重写的方法

　　　　　　　　};　　　　　　匿名内部类不是一个类，而是一个对象

12、异常　　　　-->出现异常之后的语句无法执行

　　　　1）Throwable类　　　　-->所有异常的超类

　　　　　　　　a.Error　　-->不合理的应用程序不应该试图去捕获的异常

　　　　　　　　b.Exception　　-->合理的应用程序可以去捕获的异常

　　　　　　　　　　　　RuntimeException　　-->正常运行期间可能抛出的异常，不需要提前对其处理

　　　　　　　　　　　　　　ArithmeticException  -->算术异常

　　　　　　　　　　　　　　ArrayIndexOutOfBoundsException　　-->矩阵超出异常

　　　　　　　　　　　　其他类异常（编译时期异常）　　-->必须进行处理

　　　　2）语法：　　try{执行时可能出现异常的语句

　　　　　　　　　　　　　　}catch(Exception e){

　　　　　　　　　　　　　　　　捕获异常后希望继续执行的语句}

　　　　　　　　　　e.printStackTrace();打印异常跟踪　　　　-->调用了另一个线程

　　　　3）多个异常　　-->a.连续多个catch代码段，分开处理　　b.一个catch中多个异常以'|'分隔

　　　　　　　　注意：前边 的catch不能是后边catch的父类

　　　　4）编译时期异常　　-->SimpleDateFormat类　　-->Date类和字符串的转换

　　　　　　　　a.Add throws declaration　

　　　　　　　　　　　　抛出编译异常的方法将异常抛给调用该方法的方法去捕获处理

　　　　　　　　b.Surronded with try/catch

　　　　5)throw关键字，用于手动抛出异常对象　　-->throw new 异常();

　　　　　　　　a.抛出运行时异常，可不处理

　　　　　　　　b.抛出编译时异常，必须处理

　　　　　　　　c.可以在创建异常对象时通过有参构造方法传递一个信息给父类

　　　　6）finally关键字　　　　-->try{}catch(){}finally{这里的语句一定会执行}

　　　　7）自定义异常

　　　　　　　　a.继承异常的父类

　　　　　　　　b.重写构造方法，传入一个字符串参数并调用super(message)