Java 笔记

构造函数

1.默认:如果类没有实现构造函数编译器将自动编译一个没有参数的构造函数代码到定义的类当中.

2.没有参数:没有参数的构造函数.

3.带有参数:构造函数当中不带有参数

例:带有参数的构造函数

class Test{
Test(int a){

}
Test(String a){
}
}

注意:

1.构造函数是以函数名称以及参数类型决定(不可以重复定义参数个数相同,类型相同的构造函数)

2.构造函数可以通过

this

访问另一个构造函数

this.test(1, "s")

3.

super

函数可以访问父类的函数,包括构造函数

4.构造函数不需要返回任何类型

5.构造函数可以是私有类型,只能在类的内部被访问

6.方法可以和构造函数有返回类型,但是方法有引用类型

静态函数与静态变量

对于static静态函数与静态变量我们可以直接进行调用.

class Test{
public static a = 10;
public static method(int a){
System.out.println(a);
}
Test(String a){
method(1);
}
}

静态块

有个新颖的概念叫做静态块,用于初始化声明的静态变量,按声明的顺序执行.静态块当中可以包含函数调用.

class Test{
public static test;
static{
test = 10;
System.out.println(test);
}
public static method(int a){
System.out.println(a);
}
Test(String a){
method(1);
}
}

静态方法的调用的方式

对于静态变量而言都是可以通过,实例或者类进行访问,但是不推荐用实例去访问静态变量影响其封装性,会有警告提示.

对于静态方法,静态方法当中可以直接访问静态变量,对于非静态变量与非静态方法只能通过对象进行访问.

静态类

仅当一个类为嵌套定义时,一个类可以被定义为静态类.

嵌套静态类不需要外部类的引用.

静态类不能访问外部类的非静态成员.

class Test{
public static test;
public static method(int a){
System.out.println(a);
}
static class Foo{
public void start(){
System.out.println(test);
}
}

public static void main(String args[]){
Test.Foo t = new Test.Foo();
t.start
}
}

继承

子类的构造函数默认会访问父类的默认构造函数.

extends 关键字实现继承

通过

super()

访问父类的构造方法或者

super.

访问到父类的变量成员方法.

多继承

JAVA当中不支持多继承

三种方式重载方法

方法重载:允许一个类存在相同的函数名,参数列表是不同的.

注意参数的类型需要:

1.参数个数

2.参数的类型

3.参数的顺序

重写

可以用@Override 标注重写父类的方法.

重写方式注意:

1.参数列表当中的参数与父类方法需要一致

2.私有方法,final方法,静态方法不可以被重写.

3.子类不能限制父类方法的访问级别(public -> private是不可以的 private -> public是可以的).

4. 子类重写方法当中checked exceptions 不能比父类的方法更多

5. 重写方法的绑定发生在运行时

6. 对于继承与抽象类或者接口的需要把所有方法都重写

静态绑定与动态绑定

静态绑定:发生在编译时期,因为静态方法不能被重写,类型决定了其调用哪个静态方法.

动态绑定:运行时创建的对象决定其访问那个对象方法.

class Foo{
public static method(int a){
System.out.println("FOO:" + a);
}
public static echo(int a){
System.out.println("FOO:" +a);
}
}
class Test extends Foo{
public static test;
public static method(int a){
System.out.println("TEST:" +a);
}
public static echo(int a){
System.out.println("TEST:" +a);
}

public static void main(String args[]){
Test t = new Test();
Test f = new Foo();
t.method(10);//TEST:10
f.method(10);//TEST:10
t.echo(10);//TEST:10
f.echo(10);//FOO:10
}
}

抽象类

1.抽象类不能被实例化

2.继承类需要实现对应的abstract方法

3.抽象类也可以实现具体的方法

4.抽象类可以继承于常规类

5.抽象类可以拥有任意访问级别的变量

注意:静态方法不能声明为抽象方法

abstract class Test{
public static void test(){

}
public abstract void method(int a);
}

接口

1.接口可以一次继承多个接口

2.接口只能声明public抽象方法

3.接口只可以声明public static final constant变量

interface Test{
int a = 10;//实际的类型也是public static final constant类型

public void test();
}

包

定义一个包:

package mypak.subpak;
public class  Test{

}

导入一个包:

import pack.subpack.class;

import pack.*;

import mypak.subpak.Test;

异常

try {
//Statements that may cause an exception
}
catch (MyException e) {
//Handling exception
}
catch (TestException e) {
//Handling exception
}
finally {
//Statements to be executed
}

tryblockreturn返回后finallyblock块还是会被执行.

public static int myMethod()
{
try {
return 112;
}
finally {
System.out.println("This is Finally block");
}
}

使用throws关键字标明方法会抛出的检验异常(checked exception)

class Test{
public void test() throws IOException, ClassNotFoundException{

}
}

使用自定义的异常只需要继承,使用thorw关键字抛出异常

class MyException extend Exception{
}

释文

@Override    表示重载
@Deprecated   表示方法废弃
@SuppressWarnings  抑制警告

@suppressWarnings("deprection")
public void test(){

}