Java学习笔记_图文

Java 学习笔记 一、break 语句的用法
? 汇总: 在 Java 中, 或者在编程中 (其实 C 语言和其它语言也有大致雷同用法) , break 有三种用法,其中的两种非常常用,就是 switch 语言的 break 终止和循 环语句中(for,While,do While)的 break 跳出循环。第三种不常用,就是做 为“goto“语句跳到指定位置。 先来说说常用的两种:

1、Switch 中的 break,跳出语句,代码如下:
public static void main(String[] args) { int i = 5; switch(i){ case 1: System.out.println("this is "+1); break;//break 根據業務需求來決定是否添加 case 2: System.out.println("This is "+ 2); break; case 3: System.out.println("This is "+ 3); break; case 4: System.out.println("This is "+ 4);

break; case 5: System.out.println("This is "+ 5); break; default: System.out.println("This is "); } }

2、以 for 循环为例;
注意:单循环代码如下: public static void main(String[] args) { int i = 10; for(;i<=100;i++){ if(i==12){ break; } System.out.println("this is i:"+i); } }

3、用双 for 循环为例;
代码如下: public static void main(String[] args) { int i = 10; for(;i<=15;i++){ for(int j=0;j<=i;j++){ System.out.print(j+" "); if(j==3){ break; } } System.out.println("this is i:"+i); } }

4、break 作为”goto“使用
说明: break 语句除了在 switch 语句和循环中使用之外,它还能作为 goto 语句 的一种“文明”形式来使用。Java 中没有 goto 语句,因为 goto 语句提供了 一种改变程序运行流程的非结构化方式。这通常使程序难以理解和难于维护。它 也阻止了某些编译器的优化。但是,有些地方 goto 语句对于构造流程控制是有 用的而且是合法的。 例如, 从嵌套很深的循环中退出时, goto 语句就很有帮助。 因此,Java 定义了 break 语句的一种扩展形式来处理这种情况。通过使用这种 形式的 break,你可以终止一个或者几个代码块。这些代码块不必是一个循环或 一个 switch 语句的一部分, 它们可以是任何的块。 而且, 由于这种形式的 break 语句带有标签,你可以明确指定执行从何处重新开始。你将看到,break 带给你 的是 goto 的益处, 并舍弃了 goto 语句带来的麻烦 (以上为引用, 说的太好了) 。

5、break 做为“goto”:
public static void main(String[] args) { first:for(int i=0;i<=10;i++){ for(int j=0;j<=i;j++){ System.out.print(j+" "); if(j==5){ break first; }

} System.out.println(); } }

? 7 总结: break 设计初衷并不是提供一种正常的循环终止的方法。循环的条件语句 是专门用来终止循环的。只有在某类特殊的情况下,或者业务需要,才用 break 语句来取消一个循环。

二、对象数组
1、定义: 数组是一组相同类型数据的集合。 数组是引用数据类型,类也是数据类型,所以,对象数组,就是引用数据类型种 装这多个引用数据类型。 对象数组的使用中要注意, 先开辟空间, 但是因为是其内部装的是引用数据类型, 所以数组里的每个对象都是 null 值,在使用的时候,数组的中的每一个元素要 分别进行实例化。 2、对象数组的声明格式: A、动态声明:
类名称 数组名称[]=new 类名称[数组长度]

2,静态声明:
类名称 数组名称[]={new 类(),new 类(),new 类(),??.}

动态创建对象数组: class Person{ private String name ; // 姓名属性 publicPerson(String name){ // 通过构造方法设置内容 this.name = name ; // 为姓名赋值 } public String getName(){ returnthis.name ; // 取得姓名 } }; publicclass ObjectArrayDemo01{ publicstaticvoidmain(String args[]){ // 类名称 数组名称[] = new 类名称[长度] Person per[] = new Person[3] ; // 开辟了三个空间大小的数组 System.out.println("============== 数组声明 =================") ; // 对象数组初始化之前,每一个元素都是默认值 for(int x=0;x<per.length;x++){ // 循环输出 System.out.print(per[x] + "、") ; // 因为只是开辟好了空 间,所以都是默认值 } // 分别为数组中的每个元素初始化,每一个都是对象,都需要单独实例化 per[0] = new Person("张三") ; // 实例化第一个元素 per[1] = new Person("李四") ; // 实例化第二个元素 per[2] = new Person("王五") ; // 实例化第三个元素

System.out.println("\n============== 对象实例化 =================") ; for(int x=0;x<per.length;x++){ // 循环输出 System.out.print(per[x].getName() + "、") ; // 此时,已经 实例化完成了,所以会直接打印出姓名 } } }; 静态创对象建数组: class Person{ private String name ; // 姓名属性 publicPerson(String name){ // 通过构造方法设置内容 this.name = name ; // 为姓名赋值 } public String getName(){ returnthis.name ; // 取得姓名 } }; publicclass ObjectArrayDemo02{ publicstaticvoidmain(String args[]){ // 声明一个对象数组,里面有三个对象,使用静态初始化方式完成 Person per[] = {new Person("张三"),new Person("李四"),new Person("王五")} ; System.out.println("\n============== 数组输出 =================") ; for(int x=0;x<per.length;x++){ // 循环输出 System.out.print(per[x].getName() + "、") ; // 此时,已经 实例化完成了,所以会直接打印出姓名 } } };

三、包装类
针对于原生数据类型的包装。 所有的包装类 (8 个) 都位于 java.lang 包下。 Java 的八个包装类分别是 Byte, short, integer, long, float, double, character, boolean,都可以实现原生数据对于包装类型的双向转换

四、数组
相同类型数据的集合 1、定义数组:int[] a = new int[4]; 其中 a 是一个引用,它指向了生成数组对象的首地址 Type[] 变量名 = new type[]{逗号分隔的初始化列表} 2、length 一旦确定便不可以赋值 3、二维数组:同一维数组的声明方式 4、在传值操作时如果只是传对象的话,那么方法并不改变最终的结果 5、冒泡排序

五、常量和迭代
1、常量的命名规则:所有单词的字母都是大写,如果是多个单词,使用下划线 连接:AGE_OF_PERSON 2、声明 final 常量时通常都会加上 static 关键字,这样对象的每个实例都会访问 唯一的常量值 3、迭代函数

5、Map(映射)

六、异常
1、对于运行时异常(runtime exception),我们可以不对其进行处理,也可以进 行处理,推荐不进行处理 2、 NullPointerException 是空指针异常, 出现该异常的原因在于某个引用为 null, 但是你却调用了它的某个方法。这时就会产生异常 3、对于非运行时异常(checkedexception) ,必须要对其进行处理,处理方法有 两种:第一种是 try…catch…finally 进行捕获。第二种是调用该会产生异常的方 法所在的方法声明 throwsexception 4、Java 中所有的异常类都会直接或者间接继承自 exception 5、所谓的自定义异常,通常就是定义了 一个继承自 exception 的子类,呢么这 个类就是一个自定义异常类。通常情况下直接继承自 exception 类,一般不会继

承自运行时的异常类。 6、异常类

七.输入输出流 八.GUI
1.border 布局管理器

2.事件处理器:一种交互的方法 当单击一个按钮的时候就会产生一个事件处理器(ActionEvent) 3.事件处理器:add***listener 方法

九.继承和多态
1.基本语法:
public class Sub extends Base{ } 当 Sub 和 Base 在同一个 package 时, Sub 继承了 Base 中的 public、 protected 和默认 (即 未指定访问级别)访问级别的成员变量和方法。 当 Sub 和 Base 在不同 package 时,Sub 继承了 Base 中的 public、protected 访问级别的 成员变量和方法。 2.Java 不支持多重继承,但可以通过串行的间接继承进行多重继承 3.所有 Java 类都直接或间接的集成了 java.lang.object 类。Object 类定义了 Java 对象具有 的相同行为。

4.重载 overload 同一个类中,相同名字的方法,但是参数类型、个数或者顺序至少有一项不同。 5.覆盖 override 子类覆盖了父类的方法,子类方法的名字、参数签名、返回类型必须与父类相同。若想怪边 返回类型等,但是还想用同一个名字,则可以使用先覆盖再重载的策略: public class Base{ public void method(){ } } public class Sub extends Base{ public void method(){//覆盖 Base 类的 method 方法 } public int method(int a){//重载 Sub 类的 method 方法 } } 注意: a.子类方法不能缩小父类方法的访问权限(可以扩大) ,而且子类不能抛出比父类方法更多 的异常, 其必须抛出和父类方法抛出的相同的异常, 或者子类方法抛出的异常类是父类方法 抛出的异常类的子类。 b.父类的静态方法不能被子类覆盖为非静态方法。同样,父类的非静态方法不能被子类覆盖 为静态方法。 c.子类可以定义与父类的静态方法同名的静态方法,以便在父类中隐藏父类的静态方法。子

类覆盖静态方法和覆盖一般方法的区别是,运行时,JVM 把静态方法和所属类绑定,而将 一般方法和所属实例绑定。 d.父类的私有方法不能被子类覆盖。虽然不会出现编译错误,但是实际上子类并没有从父类 继承这个方法,所以,其并没有覆盖关系。 e.父类的抽象方法通过子类实现父类的抽象方法或者子类重新声明父类的抽象方法来实现 覆盖。 f.父类的非抽象方法可以被覆盖为抽象方法。 6.super 关键字 super 和 this 的功能都是使被屏蔽的方法或变量变为可见。 不能在静态方法或者静态代码块 内不能使用 super 关键字。 7.多态 实质:指当系统 A 访问系统 B 的服务时,系统 B 可以通过多种实现方式来提供服务,而这 一切对系统 A 是透明的。例如: public class Feeder{ public void feed(Animal animal,Food food){ animal.eat(food); } } Feeder feeder=new Feeder(); Animal animal=new Dog(); Food food = new Bone(); feeder.feed(animal,food);//喂狗骨头吃

animal=new Cat(); food = new Fish(); feeder.feed(animal,food);//喂猫鱼吃 注意 animal 被定义为 Animal 类型,但是有可能引用 Dog 或 Cat 类型,在调用 animal.eat 的时候,JVM 会执行 animal 变量所引用的实例的 eat 方法。 需要注意的是: 1)静态绑定:对于一个引用类型的变量,Java 编译器按照它声明的类型来处理。例如, Base who = new Sub(); 这个 who 是 Base 类型的引用变量,Java 编译器就会按照 Base 类型来处理。要访问 Sub 类的成员,则使用强制类型转换:((sub)who).subVar="123"; 这适用于成员变量(包括静态变量和实例变量) ,静态方法 2)动态绑定:对于一个引用类型的变量,运行时 JVM 按照其实际引用的对象的方法进行 绑定。实例方法就属于这一类。 3)Java 允许在具有直接或间接的继承关系的类之间进行类型转换,对于向上转型,不必使 用强制类型转换。 继承的利弊: 提高代码可重用性,是提高系统扩展性的有效手段。但是继承树若是异常复杂,或被随意扩 展,反而会削弱系统的可扩展性和可维护性。继承的最大弱点是打破了封装,削弱了子类的 独立性。 继承的原则: 1)不考虑 Object,继承树应该尽量保持在两到三层。 2)当一个系统使用一棵继承树上的类时,应该尽可能地把引用变量声明为继承树的上层类

型。 3)若继承树上有接口类型,那么应该尽可能地把引用变量声明为继承树上层的接口类型。 4)上层完成那些适用于所有子类或大多数子类的方法,否则则设定为抽象方法。 5)在设计继承类的时候,尽可能的封装父类的实现细节,也就是把代表实现细节的属性和 方法定义为 private 类型,若某些实现细节必须被子类访问则设为 protected 类型。 6)将不允许子类覆盖的方法定义为 final 类型。 7)父类的构造方法中不要调用可以被子类覆盖的方法。 8)某些类不是为了继承而设计的,那么采用将类声明为 final 类型,或者将这个类的所有构 造方法声明为 private 类型,然后通过一些静态方法来负责构造自身的实例的两种方法禁止 继承。 9)对于一棵设计合理的继承树,子类之间会具有不同的属性和行为。 10)组合关系指的是:类 A 中包含有类 C 的属性,则类 A 称为包装类(整体类) ,而类 C 称作被包装类(局部类) 。在开发中,组合关系虽然不比继承关系减少代码量,但是维护起 来, 有更好的松耦合性。 不使用继承, 而是在类中加入要继承的类的一个实例成员就是组合。 继承关系是静态的,在运行时,子类无法改变它的弗雷,但组合关系在运行时可以根据需要 改变实现方式。在继承关系中,子类只能继承父类的接口,不能取消父类的方法,但是除非 覆盖该方法,并直接抛出 java.lang.UnsupportedOperationExcepetion。而组合则不会自动 去继承父类的方法。

知识点
1.3d2f 是什么意思

2.final,finally,finallize 3.


相关文档

【读书笔记】java学习笔记
java基础学习笔记2
Java-学习笔记(一)
Java学习笔记(必看经典
javaWeb学习笔记
java学习笔记(1)
Java学习笔记精彩版
java学习笔记整理(齐全)
Java基础学习笔记资料
电脑版