Java学习笔记

标签：

Java

老师: 周海  马政

Write Once，Run Anywhere!

1. Java介绍

• 第一代语言
  • 第一代语言或机器语言是一种低级的面向计算机的程序设计语言，使用0和1表示各种命令。 
• 第二代语言
  • 汇编
• 第三代语言
  • C、Pascal、Fortran面向过程的语言
  • C++面向过程/面向对象
  • Java跨平台的纯面向对象的语言
  • .NET跨语言的平台
• Java是sun(Stanford University Network) 公司，1982年成立，java的主要设计者是James Gosling，来源一个为电子消费产品项目Green。
• 95年，Sun发布JDK1.t0
• 98年，JDK1.2，更名为Java2
• 后续JDK1.3、1.4
• JDK1.5，更名为Java 5.0
• 我们使用jdk1.6
• 最新版jdk1.7
• ……
• Java一种健壮的语言，吸收了C/C++ 语言的优点，但去掉了其影响程序健壮性的部分（如：指针、内存的申请与释放等）。
• 简洁有效
• 可移植性
• 面向对象
• 解释型适合分布式
• 具有多线程处理能力
• 具有较高的安全性
• 是一种动态语言（可以将代码插入到正在运行的程序中）

• Software Devleopment Kit (软件开发包)
• Java Runtime Environment (Java运行环境)
• 开发需要JDK Java Devleopment Kit
• 用户只需JRE Java Runtime Environment
• 安装完需要配置环境变量
  • Path JDK中的bin文件路径
  • classpath 设置字解码环境变量，字解码文件的执行路径
  • ‘.’ 在路径上表示当前目录
  • Java_home JDK的根目录

• 最主流的是Sun公司发布的JDK
• 除了Sun之外，还有很多公司和组织都开发了自己的JDK
  • IBM公司开发的JDK， IBM的JDK包含的JVM（Java Virtual Machine）运行效率要比Sun JDK包含的JVM高出许多
  • BEA公司的Jrocket，专门运行在x86平台的Jrocket在服务端运行效率也要比Sun JDK好很多
  • GNU组织开发的JDK
  • 现在andr手机开发使用的是Google公司的JDK
• Java跨平台依于JVM虚拟机 －Java Virtual Machine
• Java所有代码写在类中，类名大写
• 一个Java可以定义多个类，但不同类会生成不同的class文件
• 只能有一个public类，并且类名要与文件名相同
• Java严格区分大小写哦
• 编写完后在cmd\终端中编译javac file_name.java
• 编译完后产生file_name.class文件，为字解码文件
• Java两种核心机制：
  • Java虚拟机 Java Virtual Machine

• Java虚拟机可以理解成一个以字节码为机器指令的 CPU。
• 对于不同的运行平台，有不同的虚拟机。
• Java 虚拟机机制屏蔽了底层运行平台的差别，实现了“一次编译，随处运行”。

• 垃圾收集机制 Garbage Collection

• 不再使用的内存空间应回收－垃圾收集。
• 在C/C++ 等语言中，由程序员负责回收无用内存。
• Java语言消除了程序员回收无用内存空间的责任；它提供一种系统级线程跟踪存储空间的分配情况。并在JVM的空闲时，检查并释放那些可被释放的存储器空间。
• 垃圾收集在Java程序运行过程中自动进行，程序员无法精确控制和干预。

• Java注释：

• ／／               当行注释
• ／＊

      多行注释

• ＊／
• ／＊＊

          文档注释，且可被doc工具解析

• ＊／

• 在cmd／终端输入java －version 查看JDK版本
• Java －verbose file_name 查看执行class文件的过程

1. Java基础

• 标识符：Java语言中，对各种变量、方法和类等要素命名时使用的字符序列

• 由字母、下划线_ 、美元符号$或数字组成
• 以字母、下划线、美元符号开头
• 区分大小写，长度无限制
• 应注意“见名知意”且不能与Java的关键字同名

• Java所有关键字都是小写英文字符串

• 变量：最基本的存储单元，包括变量名，变量类型，作用域
• Java每一个变量都属于特定的数据类型，在使用前必须对其声明

• 例：int i ＝ 10；
•       float ＝ 12.3f；

• 从本质来讲，变量为内存中的一小块区域，使用变量名来访问这块区域，因此每一个变量使用前必须先声明，然后赋值
• 按被声明的位置划分：

• 局部变量：方法或语句快内部定义的变量，可以不用初始化赋值，有默认值（byte－0、short－0、int－0、long－0L、float－0.0L、double－0.0d、char－\u0000、boolean－false）
• 成员变量：方法外部、类的内部定义的变量，必须初始化进行赋值

• 按所属的数据类型划分：

• 基本数据类型变量
  • 数值型
    • 整数类型（byte、short、int、long）
      • 在定义long变量时在值后加L
      • 在定义float变量时在值后加F
    • 字符型（char）
    • 布尔型（boolean）
• 引用数据类型变量
  • 类（class）
  • 接口（interface）
  • 数组

• Java字符采用Unicode编码，每个字符占用两个字节，因此可用十六进制编码形式表示，Java支持汉子做类名、函数名和变量名
• byte、short、char -> int -> long -> float -> double

• byte、short、char之间不会互相转换，他们三者在计算时首先会转换为int类型
• 容量大的数据类型转换为容量小的数据类型时，要加上强制转换符，但要注意造成精度降低或溢出

• Java运算符：

• 算术运算符： + , - , * , /(整除) , %(取模，取余数) , + + , - -
  • + + number :先加，再参与所在表达式运算 
  • number + + :先参与所在表达式运算，后加
  • 关系运算符：> , < , >= , <= , = = , ! = , = = =
    • = = :值相等就可以
    • = = = :数据类型要相等才可
• 逻辑运算符 : ! , & , | , && , | |

• int a = 3;
• int b = 2
• int a = 3 & & int b =2
  • & & : 短路与，前错便不再运算后
• int a = 3 | | int b =2
  • | | : 短路或，前对便不再运算后
• 位运算符：& , | , ^(异或) , ~(取反) , > >(右移) , < <(左移) , > > >(无符号右移，用0填充)
  • & :                        | :
  •     int a =2                  int a = 2 
  •     int b = 3                 int b = 3
  •     1 0  = 2                1 0    = 2
  • &   1 1  = 3            |    1 1    = 3
  • ———————      ————————
  •     1  0 = 2                 1 1    = 3 
  •     a & b = 2               a | b = 3

           同1为1                   有1为1

• ^：                       ~ :
•     int a = 2                 int a = 2
•     int b = 3                 int b = 3 
•     1 0  =  2                   ~3 = -4
•     1 1  =  3              补码＝源码＋取反＋加1
• ———————               负数以补码形式
•         1  =  1

         相等为0

         不同为1

• >> :                          << :                      >>> : 
• 2                             1                       用0补符号位
• ……010                  ……001                  负数变为正
• >>                            << 
• ……001                  ……010
• 1                            2
•       正负数符号位不变

• 表达式优先级问题，用括号处理
• 三目运算－条件表达式：

• int score = 2;
• String grade = score < 60 ? “不及格”: “及格”;

• For循环

• for(__;__;__){

}

• while & do while 
• while(  ){                       do{

}         }while(  )

• break  (跳出本次循环);   continue  (结束当此循环);

• 方法

[修饰符1，修饰符2…] 返回值类型 方法名（形参）｛

｝

• 方法重载:方法名相同，参数个数或类型不同，方法重载和返回值无关
• 递归调用
• 数组

• 一维数组 
• int a[] = new int[3]        数组名为首地址，为hc编码常量
• public void setName(String name){
• this.name = name           this代表的是当前对象实例
• }

• 二维数组，由多个一维数组组成
• Java中，二维数组的列数可以不一样
• 二维数组名.length 为二维数组的行数
• a[i].length i行的长度   
• 定义 ： int [ ] [ ] b = new int [3] [ ] 列可以不写，不写死范围

• 类 Arrays 工具类 (API查找)

• sort ( )  排序    要饮用包调用工具类 import java.util.Arrays;
• copyofRange ( )     复制数组

• 数组的比较

• int[] a = {          };
• int[] b = {          };
• a = = b  此类比较的为地址比较
• Arrays.equal(a,b) 数组大小的比较（内容比较）
• 饮用类型赋值时赋的为地址值

• Java新特性

• 可变参数
• public void text(int …args){
• //args是数组

• foreach 输出    （关键字为for）
• public void text (int … args){
  • for(int x : args){
  • System.out.println(x)
  • }
• }

• 输入问题

• pbulic static void main(String[] args) //接受外部输入的参数

• 使用输入流

• 先用引包 import java.util.*;
• 然后 Scanner in = new Scanner (Scanner.in);     Scanner 类
•         num = in.nextInt();

• 生成说明书 

• Javadoc -d doc_name DocDemo.java
• javac -d doc_name -authoe -version DocDemo.java
• 生成的类必须为公有的

• 面向对象

• 对象通过属性和方法来分别对应事物所具有的静态和动态

• 开发：

• 首先考虑有哪些类来找对象
• 其次要做哪些功能由谁来功能

• 面向对象的特质

• 封装(encapsulation)：
• 继承(inheritance):
• 多态(polymorphism):

• 构造函数：

• 函数名与类名相同
• 不用定义返回值类型
• 不用写return语句
• ／／如果没有有参的构造方法，系统会自动创建一个无参数的构造方法

• 注意：一旦人为定义了有参数的构造方法，系统就不再闯进无参的构造方法
• 一个成员变量有了set get方法后可以称为属性
• 一般写两个，一个无参，一个全部参赛属性的构造函数
• this指当前对象实例，指当前构造函数，由后面参赛确定

• this调用只能放在构造方法的第一行
• new ->实例化对象

• String

• 由于String 太常用，对String作了优化
• String info1 ＝ “好人”
• String info2 ＝ “好人”
• 以这种方式创建实例，如果值相同那地址就相同

• equals 
• String username = “haoren”;       String username = “haoren”;
• if(username.equals(“haoren”)){     if(“haoren”.equals(username)){
• System.out.println(“yiyang”):        System.out.println(“yiyang”);
• }                                           }
  • 使用equals将匹配的值放前，可以避免空指针异常
  • 异常不等于错误

• charAt（）
• String name = “我是好人，你是吗？”
• System.out.println(name.charAt(4));
•     //输出    ，    

• matches 验证字符中是否匹配正则表达式
• String email = “haoren@sina.com”;
• if (email.matches( “               “ )){
• }
• 转义字符：有特定字符被系统占用，有特殊意义

• split()     分割
• public class Text{
•   public static void main(String[] args) {
•     String hobby = "睡觉，足球，跑步，打豆豆";
•     String[] hby = hobby.split("，");
•     for(String x:hby){
•       System.out.println(x);
•     }
•   }
• }

• startsWith()      判断以什么开头
• public class Text{
•   public static void main(String[] args){
•       String name = "我是好人";
•       System.out.println(name.startsWith("我"));
•   }
• }
• true

• endsWith()    判断以什么结尾
• public class Text{
•   public static void main(String[] args){
•       String name = "我是好人";
•       System.out.println(name.endsWith("人"));
•   }
• }
• true

• String Buffer()   连接 需要进行字符串的反复拼接使用StringBuffer，速度快，   //buffer缓冲区
• public class Text{
•   public static void main(String[] args){
•       StringBuffer sb = new StringBuffer("haoren");
•       sb.append("i");
•       System.out.println(sb);
•   }
• }
• haoreni

• int a = 23;
• String s = a + “”;  
• 快速变字符串

• trim()     去掉两边空格
• public class Text{
•   public static void main(String[] args){
•       String name = "      haoren       ";
•       String a = name.trim();
•       System.out.println(a);
•   }
• }
• haoren

• 类名首字母大写，方法第二个字母大写

• replace()     替换
• public class Text{
•   public static void main(String[] args){
•       String a = "haoren";
•       System.out.println(a.replace("haoren","huairen"));
•   }
• }
• huairen

• 返回数组
• public int[] text(){
• int a;
• int b;
• return b;

• static 
• 方法只在内存中存一份(代码区)
• 栈stack    堆heap     静态存储区        代码区   
• static 用于修饰成员(成员变量和成员函数)修饰成员变量时，可以实现数据共享
• static 修饰后的成员：
  • 随着类的加载而加载
  • 优先于对象存在
  • 被所有对象所贡献
  • 可以直接被类名所调用
  • 注意：
  • 静态方法只能访问静态成员
  • 静态方法中不可以写this，super关键字
  • 主函数是静态的
• static是一个修饰符，用于修饰成员。
• static修饰的成员被所有的对象所共享。
• static优先于对象存在，因为static的成员随着类的加载就已经存在了。 
• static修饰的成员多了一种调用方式，就可以直接被类名所调用 。 类名.静态成员 。
• static修饰的数据是共享数据，对象中的存储的是特有数据。
• 成员变量和静态变量的区别？
• 两个变量的生命周期不同。
• 成员变量随着对象的创建而存在，随着对象的被回收而释放。
• 静态变量随着类的加载而存在，随着类的消失而消失。
• 调用方式不同。
• 成员变量只能被对象调用。
• 静态变量可以被对象调用，还可以被类名调用。
• 别名不同。
• 成员变量也称为实例变量。
• 静态变量称为类变量。 
• 数据存储位置不同。
• 成员变量数据存储在堆内存的对象中，所以也叫对象的特有数据.
• 静态变量数据存储在方法区(共享数据区)的静态区，所以也叫对象的共享数据.
• 1，静态变量。
• 当分析对象中所具备的成员变量的值都是相同的 。
• 这时这个成员就可以被静态修饰。
• 只要数据在对象中都是不同的，就是对象的特有数据，必须存储在对象中，是非静态的。
• 如果是相同的数据，对象不需要做修改，只需要使用即可，不需要存储在对象中，定义成静态的。
• 2，静态函数。
• 函数是否用静态修饰，就参考一点，就是该函数功能是否有访问到对象中的特有数据。
• 简单点说，从源代码看，该功能是否需要访问非静态的成员变量，如果需要，该功能就是非静态的。
• 如果不需要，就可以将该功能定义成静态的。当然，也可以定义成非静态，
• 但是非静态需要被对象调用，而仅创建对象调用非静态的
• 没有访问特有数据的方法，该对象的创建是没有意义。

• static 修饰的变量，可以被各个实例所贡献，被放在了静态存储区
• 静态方法只能访问静态属性
• 静态方法可以通过类名来访问静态方法

• 普通代码块
• public static void main(String[] args){
• {
•   int num1 = 4;
•   S.o.p (num1);
• }
•   int num1 = 5;
•   S.o.p(num1);
• }

• 构造代码块：构造代码块先于构造方法执行
• 普通代码块先于构造函数执行
• 静态代码块随着类的加载而执行，只执行一次，比普通代码块快
• 静态代码块先于主方法执行，在类中静态代码块先于构造代码块执行，代码块又先于构造方法执行
• 在类中执行，只执行一次，用静态代码块，如连接数据库
• 在每个实力创建前，预先动作。

• 单例设计模式

• 饿汉式     一加载就创建实例
• class single{
• private static single s = new single();
• private single(){
• }
• public static Sintle getSingle(){
• retunrn a;
• }

• 懒汉式      使用到的时候才创建实例，第一次使用时
• class single{
• public static Single s;
• private single(){
• public static Single getSingle(){
• if(s!==null)
• return s ;
• else{
• s = new Single();
• retur s }
• }

• 继承     extends
• 多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承单独的那个类即可。
• 多个类可以称为子类，单独这个类称为父类或者超类。
• 子类可以直接访问父类中的非私有的属性和行为。
• 通过 extends 关键字让类与类之间产生继承关系
• 继承的出现提高了代码的复用性。
• 继承的出现让类与类之间产生了关系，提供了多态的前提
• 要访问父类的私有属性必须用共有的set和get方法
• 子类不能降低父类继承过来的方法的权限
• super：  可以访问父类的构造函数    调用父类的方法   
• this.方法名    调用本类中的方法
• 在创建实例中，子类在实例化过程，全自动调用父类的构造方法(无参)
• Java只能单继承和多层继承
• 函数覆盖
• 子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重
• 写或者复写。
• 父类中的私有方法不可以被覆盖。
• 在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名
• 获取。
• 子类权限一定大于父类权限
• 静态只能覆盖静态方法

• 所有的类都默认继承Object类
• 直接输出类名输出的是 toString 方法 （类名@hashcode）
• 函数toString重写
• public String toString(){
• return “    ”;      修改为“    ”语句

• final
• final可以修饰类，方法，变量。
• final修饰的类不可以被继承。
• final修饰的方法不可以被覆盖。
• final修饰的变量是一个常量。只能被赋值一次。
• 内部类只能访问被final修饰的局部变量。
• 修饰变量，此变量为常量      final a；(最终变量)；
• public final String a = “banana”;
• public static final String a = “banana”;
• //static 只创建一个静态存储区
• final 修饰方法后就不能被重写
• public fianl void test(){
• }
• 如果一个类 被final修饰，就不能被继承
• final class fruit{
•   }

• 抽象类 abstract
• Java中可以定义没有方法体的方法，该方法的具体实现由子类完成，该方法称为抽象方法，包含抽象方法的类就是抽象类。
• 类是实例的模块
• 抽象类是类的模块
• abstract class Animal{
  • public abstract void run();        //写模块，不写方法体
  • public abstract void sleep();
  • }
  • class Person extands Animal｛
  •                 //重写方法
  • 一个类继承一个抽象类就必须实现抽象类中的所有方法
  • 抽象类不能实例化，但是有构造方法
  • 抽象类可以有非抽象方法
  • 空方法体也是实现

• 接口 interface {}
• 接口就是标准
• 接口里只有常量和抽象方法
• implements 实现
• interface USB {
• //public static final double width = 1.5;
• public width = 1.5;
• }
• //public abstract void getConnetion () ;
• void getConnetion();
• }
• 一个类可以实现多个接口，类可以同时继承抽象类和接口
• 多实现
• 多继承
• 多层继承

• 在面临选择接口还是抽象类时，坚决使用接口，留有余地。
• 适配器类／适配器设计模式
• 抽象类实现接口时，将不要的方法写为空方法体，类再继承抽象

• 多态：
• 父类可以接受字类对象实例
• 父类接受字类，只能访问到父与子共有到方法
• Fruit f ＝ new Apple()；
• java中向下转型需向上转型
• instanceof
• 在多态中需向下转型时先判断instanceof，判断某个实例是否属于某个类型

• 设计模式
• 工厂设计模式
  • 想用即调用
  • 产生实例的方法改变
  • 工厂类来产生实例

• 代理设计模式
  • 让核心功能与其它功能分离
  • 保证其核心功能安全

• 内部类 
  • 内部类可直接使用外部的私有变量
  • 包含关系的时候
• 方法一：先有外部类实例，在new内部类
• 方法二：
  • Outer outer = new Outer();
  • Outer.Inner in = outer.new Inner();
  • in.print();

• 静态内部类
  • 普通匿名内部类：new Outer().new Inner().test();
  • 静态：new Outer.Inner().test();
  • 可以不先创建外部类。直接外部类名.内部类来new
  • 静态类访问外部静态变量

• 在方法里被定义类
  • 可以调用外部类的变量
  • 调用类要在方法里new Inner().innerTest();
  • 内部类，如果被定义在函数中，内部类要访问外部类函数的行参，行参要被final修饰
• 匿名内部类(有接口)
  • 灵活，用的时候在写
  • 一般来实现接口里的方法(无构造方法，匿名＝无名)
  • new A(){
  • public void test(){
  • System.out.println(“ok”);
  • }}.test(); 
• 接口里边可以定义内部接口和抽象类
• 抽象类里也可以定义接口和抽象类

• 包装类
  • 基本数据类型           包装类
  • int                           Integer
  • char                         Character
  • short                        Short
  • long                          Long
  • float                         Float
  • double                       Double
  • boolean                     Boolean
  • byte                         Byte
• 装箱和拆箱
• 装箱：将基本数据类型变为包装类
• 拆箱：将一个包装类变为基本数据类型
• JDK1.5后自动装箱和拆箱
• 包装类的应用：
  • String str1 = “30”;
  • String str2 = “30.3”;
  • int x = Integer.parseInt(str1);     //将字符串变为int型
  • float f = Float.parseFloat(str2);   //将字符串变为float型

• 异常
  • 异常处理不一定是解决问题，也可能是抛出问题

• 异常处理机制 Exception
  • try{
  •             //写可能出现异常的代码
  • }catch(Exception e){
  •             System.out.println(“e”):
  •             //异常输出的语句
  •             //getMessage() 获取异常信息，返回字符串
  •             //toString() 获取异常类名和异常信息，放回字符串
  •             //printSatckTrace 获取异常类名和异常信息，以及异常出现在程序中的位置，返回值void
  • }finaly{
  •             //这里的代码一定会执行，一般关闭资源的代码放这
  • }
  • 保证在出现异常处理后，正常执行后程序
  • System.out.println(0);    //强制退出虚拟机，就不会执行

• 异常处理的原则
  • 谁调用谁处理
• throws:用于标识函数暴露出的异常*(用在函数上,后面跟异常类名)
• throw:用于抛出异常对象*(用在函数内,后面更异常对象)

• 自定义异常
  • 自定义类继承Exception或者其子类
  • 通过构造函数定义异常信息
  • class DemoException extends Exception
  • {
  •   DemoException(String message)
  •   {
  •     super(message);  
  •   }
  • }

• RuntimeException()
  • 运行时异常，可以不声明跑出(throws)

• 一个方法被覆盖到时候，抛出时继承应该是相同的异常或子类
• 如果覆盖方法时，不能抛出新的异常，只能是子类

• 包
• 全限定名：包名＋类名
• 确保包类名不冲突
• 被访问的包中的类权限必须是public的
•               public     protected     default     private
• 同一类       ?              ?            ?            ?             
• 同一包       ?              ?            ?
• 不同包子类 ?              ?
• 不同包       ?   

• 父类中受保护的方法可以在不同的包中的字类所访问
• set classpath   设置路径时不能加引号
• set path＝％path％;xxx/xx/x         %path% 保存原地址

多线程(Thread)

• 继承和实现
• class MyThread extends Thread {
•     //需要在线程中运行的代码需要需要写在run方法
• public void run(){

• start 是将线程加到线程组里面
• 线程不能重复开启

• Java程序运行至少两个线程：main 和 垃圾回收线程
• Runnable 可以实现数据共享，实际是多个线程，跑的是一个对象实例
• 在实际开发中一般使用Runnable

• 线程安全问题：
•   数据共享
•   多步操作

• 同步(synchronized)
  • 一切对象都可以是锁
  • 同步代码块能不能同步，看锁(this)

• 同步函数
  • 同步函数的锁就是this

• wati() :失去cpu的执行权，且程序锁
• sleep() :失去cpu的执行权

• StringBuffer() ;
  • lastIndexof() ;
  • subString() ;

• Process 一个进程
• java.sql.Date dd = new java.sql.Date(new java.util,Date().getTime());
•   数据库时间                                     java中时间
• java中的时间不能强转为数据库的时间

• Math.random() ;
• (随机数)
• 返回带正号的double值，该值大于等于0.0且小于1.0
• (int)(Math.random() * x)+1     1~x

• 类 Random 
• 生成伪随机数
• new Random().newtInt(7));     0~7(不包含7)

• NumberFormat 
• NumberFormat.getInstance()

• 类 DecimalFormat 
• ###,###.#####
• 000,000.00000   (没有的位数用0补齐)
• String format1 = “###,###.#####”;    //格式字符   
• 小数部分不进行分组
• DecimalFormat df = new DecimalFormat(format1);
• sop(df.format(12345.123456)
• 格式字符后: ￥ $ % ‰

• 类 BigInterger 大数 

• 对象的克隆
• clone();
• 被克隆的对象必须实现cloneable接口
• 须重写object.clone()方法
• 克隆时要强转Dog d2  = (Dog) d1.clone();
• 强转后需要报异常

• Arrays 类 （数组大工具类）
• 正则表达式

• 转义字符

• 定时调度
• Timer 类

• 观察者设计模式

• 泛型
• 不能使用基本数据类型，使用包装类
• class Person<T> {

• 在类里定义泛型
  • 在泛型中，不能用父类接受字类
  • 通配符<?> 在泛型中，不知道其数据类型

• 可以限定范围
  • <?extengs Integer>只能是Integer字类和自己
  • <?super Integer>只能是Integer父类和自己

• 泛型接口 （接口：常量、抽象方法）
  • interface A<T>{
  • T fun1();       //泛型可以作为函数返回值
  • }
• 两种实现：
  • 创建实例实现
  • 定义时实现

• 泛型方法
  • 静态方法不能访问类上定义的泛型
  • class Test{
    • public <T> T fun2(T aa){
    •         return aa;
    • }

• 泛型数组
• 泛型嵌套

• 集合
  • 不限定数量的对象数组

• 两个集合：
  • collection    map

• hashcode ，equals 判断两实例是否为一个。重写两方法。

• List - ArrayLish 可以重复元素

• 父类接受子类的实例，方法只能实现共有的
• 在开发过程中，一个值的lengt(),size() 随着改变而改变，一般将值提取出来

• Collection - set 不可放入重复的元素

• HashSet

• TreeSet 有许存放
• compareable 实现可以比较
  • 让一个类可以实现比较，只需实现comparable的compareTo()方法

• 集合标准输出方式

• 迭代器
• Iterator<Student> it = mylist.iterator();
• while(it.hasNext()){
  • S.o.p(it.next()).getName);
• }
• or
• Iterator<Student> it = mylist.iterator();
• while(it.hasNext()){
  • student s = it.next();
  • S.o.p(s.getName());
• }

• 流
• File
• 字节流
• 输出字节流

Java学习笔记

标签：

原文地址：http://blog.csdn.net/yeswxc/article/details/51171945