笔记

<1>数组的创建(一定要分配内存）

int []a=new int [3]; or int []a; a=new int [3];

初始化：

静态初始化下 ， 引用类型变量不能指定维数

int    intArray[][]={{1,2},{2,3},{3,4}};  √

String [2][2]  stringArray = { {“Hello”,“world”},{“java”,“test”}};  ×

String[ ][ ] AS = new String[2][2]; √

foreach

匿名对象；

this:

1.this（）调用的构造方法必须放在第一行；

static: 

 static类型声明的属性既可以在static 方法中使用也可以在非static方法中使用。

但用 static类型的属性调用非 static类型的属性时，则会出现错误。即static仅能调用static

对象数组：Person p[]=new Person[3];

Person p[] = {newPerson(),new Person(),new Person()} ;

for(inti=0;i<p.length;i++){

p[i] = newPerson() ;

 }

内部类：

外部类是无法找到内部类中所声明的属性。而内部类则可以访问外部类的属性。

21 Outer outer = new Outer(); 
22 Outer.Inner inner = outer.new Inner(); 
23 inner.display() ; 

 

而用 static 也可以声明内部类，用 static 声明的内部类则变成外部类，但是用 static 声明的内部类不能访

 问非 static 的外部类属性。

内部类也可以通过创建对象从外部类之外被调用，只要将内部类声明为 public 即可

在方法中定义内部类：仅能访问final变量；

构造方法可视为一种特殊的方法，它的主要作用是为所创建的对象赋初值

继承：

1.

所以由此 可以得出结论，子类对象在实例化时会默认先去调用父类中的无参构造方法，之后再 调用本类中的相应构造方法。

2.

super主要的功能是完成子类调用父类中的内容，也就是调用父类中的属性或方法。

3

用 super调用父类中的构造方法，只能放在程序的第一行。super 关键字不仅可以调用父类中的构造方法，也可以调用父类中的属性或方法，

4

有些时候，父类并不希望子类可以访问自己的类中的全部的属性或方法，所以需要将一些属性与方法隐藏起来，不让子类去使用，所以在声明属性或方法时往往加上“private”关键字，表示私有（这样可以限制子类访问）

（可以隐藏的访问）

5

super 与this 不能同时出现

this：调用本类或当前对象；

super：子类调用负累；

抽象类：

1.并不能直接由抽象类创建对象，只能通过抽象类派生出新的类，再由 它来创建对象。

2.

抽象类定义规则

 

0     抽象类和抽象方法都必须用 abstract 关键字来修饰。

 

0     抽象类不能被实例化，也就是不能用 new关键字去产生对象。

 

0     抽象方法只需声明，而不需实现。

 

0      含有抽象方法的类必须被声明为抽象类，抽象类的子类必须复写所有的 抽象方法后才能被实例化，否则这个子类还是个抽象类。 

3.

注意：

在抽象类定义的语法中，方法的定义可分为两种：一种是一般的方法，它和

 先前介绍过的方法没有什么两样；另一种是“抽象方法”，它是以 abstract 关键

 字为开头的方法，此方法只声明了返回值的数据类型、方法名称与所需的参数，

 但没有定义方法体。（故抽象类里可以有非抽象方法，而这点与接口不同！）

4.

与一般类相同，在抽象类中，也可以拥有构造方法，但是这些构造方法必须在子类中被调用。

abstract class Person

 {

    String name ; int age ;

 String occupation;

 publicPerson(String name,int age,String occupation)

{this.name = name ;this.age = age ; this.occupation = occupation ;}

 public abstractString talk() ;

 }

 class Studentextends Person

 {

 publicStudent(String name,int age,String occupation)

 {

 // 在这里必须明确调用抽象类中的构造方法super(name,age,occupation);

 }

 public Stringtalk() {

 return "学生——>姓名："+this.name+"，年龄："+this.age+"，职业："+this.occupation+"！" ;

 }

 }

 class  TestAbstractDemo2

{

 public static voidmain(String[] args)

 {

 Student s = new Student("张三",20,"学生") ; System.out.println(s.talk()) ;

 }

 }

5.final关键字

0    Java 中声明类、属性和方法时，可使用关键字 final 来修饰。

 1、 final 标记的类不能被继承。

 2、 final 标记的方法不能被子类复写。

 3、 final 标记的变量（成员变量或局部变量）即为常量，只能赋值一次。

接口：

1.注意：

1、 接口里的数据成员必须初始化，且数据成员均为常量。（用final修饰）

 2、 接口里的方法必须全部声明为 abstract，也就是说，接口不能像抽象类一样保有一般的方法，而必须全部是“抽象方法”。

（由于全都是final型和abstract，故写的时候可以省略！）

 3.

每一个由接口实现的类必须在类内部复写接口中的抽象方法，且可自由地使用接口中

 的常量。

4。

一个类只 可以继承一个父类，但却可以实现多个接口。

5.接口的继承用extends（一个接口可以同时继承多个接口）

6.

01  interface Person
02  {
03 public void fun1() ;
04  }
05  class Student implements Person
06  {
07 public void fun1()
08 {
9 System.out.println("Student fun1()"); 
10 } 
11 } 
12 class TestInterfaceObject 
13 { 
14 public static void main(String[] args) 
15 { 
16 Person p = new Student() ; 
17 p.fun1() ; 
18 } 
19 } 

从上面的程序中可以发现，接口是可以被实例化的，但是不能被直接实例化，只

 能通过其子类进行实例化，

转型

异常：

throws：

package com.Exception;
import java.util.Scanner;
class MyException2 extends Exception{
private int id ;
public MyException2(String message,int id) {
super(message);
this.id=id;
}
public int getId() {
return id ;
}
}
 class RecordScoreTest {
public void recordScore() throws MyException2{
Scanner inpute=new Scanner(System.in);
System.out.println("请输入成绩！");

String score=inpute.next();

Double s=Double.valueOf(score);
if(s<0||s>100) {
throw new MyException2("请输入合理的成绩！",6);

}




}


public void manager2() {

/*Scanner inpute=new Scanner(System.in);
System.out.println("请输入成绩！");
int score=inpute.nextInt();*/
try {
recordScore();
}
catch(MyException2 e) {
System.out.println("录入失败！");
e.printStackTrace();
}
System.out.println("操作结束！");
}
public static void main(String[] args) {
RecordScoreTest t=new RecordScoreTest();
t.manager2();

}

}

ps:

1父类的引用 不可以访问 其子类对象 新增加的成员 （属性和方法）。

2调用子类构造方法时还会默认调用父类的相应的构造方法。

3.

内部类 可以访问 其外部类中的 所有 数据成员和方法成员，也可以使用 它所在方法中 的局部变量。

可以将内部类声明为 abstract ， private ，或 protected ，若被声明为 static ，就变成了 顶层类 ， 不能再使用局部变量

若 在内部类中声明任何 static 成员 ，则该 内部类 必须声明为 static 。

定义为static的内部类称为 静态内部类 。 静态内部类将自动转化为 顶层类 ，不能引用 外部类成员 或 其它内部类成员 。