JAVA API个各种方法
熟练掌握常用类及方法
String
str1.startsWith(str2)
判断str1是否以str2开头，返回true或false
str1.endsWith(str2)
判断str1是否以str2结尾，返回true或false
str1.indexOf(str2)
返回字符串str1中第一次出现str2字符的位置，返回数字，字符串第一个字符的位置为0
str1.lastIndexOf(str2)
返回字符串str1中最后一次出现str2字符的位置，返回数字，字符串第一个字符的位置为0
str1.split(str2)
将字符串str1以str2为分隔符，分割成字符串数组，返回字符串数组
str1.equals(str2)
判断字符串str1是否与字符串str2相等，返回true或false
str1.substring(i,j)
i,j为整型变量，取字符串str1从i到j之间的子串，返回String
str1.substring(i)
i为整型变量,取字符串str1从i到结尾之间的子串，返回String
str1.replace(char c1,char c2)
把字符串str1中包含c1字符替换为c2
str1.replateAll(String s1,String s2)
把字符串str1中包含s1字符串替换为s2
str1.getBytes()
把字符串str1转化为字节数组，返回byte[]
str1.trim()
把字符串str1的前后空格去掉
str1.charAt(i)
i为整型变量，返回字符串str1第i位置的字符
System
System.in
系统控制台输入流，PrintStream
System.out
系统控制台输出流，PrintStream
System.err
系统错误输出流，PrintStream
System. currentTimeMillis
返回以毫秒为单位的当前时间，自1970/1/1 0:0:0开始计时
System. getProperties
确定当前的系统属性，返回对象Properties (键值对)
System.exit(int status)
终止当前正在运行的 Java 虚拟机。
Integer
new Integer(int i)
构造一个新分配的 Integer 对象，它表示指定的 int 值。
new Integer(String str)
构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
static int parseInt(String s)
将字符串参数作为有符号的十进制整数进行解析。
Float
Float(float value)
构造一个新分配的 Float 对象，它表示基本的 float 参数。
Float(String s)
构造一个新分配的 Float 对象，它表示用字符串表示的 float 类型的浮点值。
static float parseFloat(String s)
返回一个新的 float 值，该值被初始化为用指定 String 表示的值，这与 Float 类的 valueOf 方法一样。
static Float valueOf(String s)
返回保存用参数字符串 s 表示的 float 值的 Float 对象。
float floatValue()
返回此 Float 对象的 float 值。
Double
Double(double value)
构造一个新分配的 Double 对象，它表示基本的 double 参数。
Double(String s)
构造一个新分配的 Double 对象，表示用字符串表示的 double 类型的浮点值。
static double parseDouble(String s)
返回一个新的 double 值，该值被初始化为用指定 String 表示的值，这与 Double 类的 valueOf 方法一样。
static Double valueOf(double d)
返回表示指定的 double 值的 Double 实例。
static Double valueOf(String s)
返回保存用参数字符串 s 表示的 double 值的 Double 对象。
Math
static float abs(float a)
返回 float 值的绝对值。
static int abs(int a)
返回 int 值的绝对值。
static double random()
返回带正号的 double 值，该值大于等于 0.0 且小于 1.0。
Object
Class<?> getClass()
返回此 Object 的运行时类。
String toString()
返回该对象的字符串表示。
void notify()
唤醒在此对象监视器上等待的单个线程。
void notifyAll()
唤醒在此对象监视器上等待的所有线程。
wait()
在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。
Thread
Thread()
分配新的 Thread 对象。
Thread(Runnable target)
分配新的 Thread 对象。
void run()
如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。
static void sleep(long millis)
在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。
void start()
使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
List
boolean add(E e)
向列表的尾部添加指定的元素（可选操作）。
void add(int index, E element)
在列表的指定位置插入指定元素（可选操作）。
boolean addAll(Collection<? extends E> c)
添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序（可选操作）。
void clear()
从列表中移除所有元素（可选操作）。
boolean contains(Object o)
如果列表包含指定的元素，则返回 true。
boolean containsAll(Collection<?> c)
如果列表包含指定 collection 的所有元素，则返回 true。
E get(int index)
返回列表中指定位置的元素。
Iterator iterator()
返回按适当顺序在列表的元素上进行迭代的迭代器。
E remove(int index)
移除列表中指定位置的元素（可选操作）。
boolean remove(Object o)
从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。
boolean removeAll(Collection<?> c)
从列表中移除指定 collection 中包含的其所有元素（可选操作）。
Object[] toArray()
返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。
Map
void clear()
从此映射中移除所有映射关系（可选操作）。
boolean containsKey(Object key)
如果此映射包含指定键的映射关系，则返回 true。
boolean containsValue(Object value)
如果此映射将一个或多个键映射到指定值，则返回 true。
Set<Map.Entry<K,V>> entrySet()
返回此映射中包含的映射关系的 Set 视图。
V get(Object key)
返回指定键所映射的值；如果此映射不包含该键的映射关系，则返回 null。
Set keySet()
返回此映射中包含的键的 Set 视图。
V put(K key, V value)
将指定的值与此映射中的指定键关联（可选操作）。
int size()
返回此映射中的键-值映射关系数。
Collection values()
返回此映射中包含的值的 Collection 视图。
Set
boolean add(E e)
如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。
boolean addAll(Collection<? extends E> c)
如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中（可选操作）。
void clear()
移除此 set 中的所有元素（可选操作）。
boolean contains(Object o)
如果 set 包含指定的元素，则返回 true。
boolean containsAll(Collection<?> c)
如果此 set 包含指定 collection 的所有元素，则返回 true。
boolean isEmpty()
如果 set 不包含元素，则返回 true。
Iterator iterator()
返回在此 set 中的元素上进行迭代的迭代器。
boolean remove(Object o)
如果 set 中存在指定的元素，则将其移除（可选操作）。
boolean removeAll(Collection<?> c)
移除 set 中那些包含在指定 collection 中的元素（可选操作）。
boolean retainAll(Collection<?> c)
仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。
int size()
返回 set 中的元素数（其容量）。
Object[] toArray()
返回一个包含 set 中所有元素的数组。
ArrayList
List的实现类，List的所有方法都包括
List lst = new ArrayList();
HashMap
Map的实现类，Map的所有方法都包括
Map map = new HashMap();
HashSet
Set的实现类，Set的所有方法都包括
Set set = new HashSet();
Hashtable
void clear()
将此哈希表清空，使其不包含任何键。
boolean contains(Object value)
测试此映射表中是否存在与指定值关联的键。
boolean containsKey(Object key)
测试指定对象是否为此哈希表中的键。
boolean containsValue(Object value)
如果此 Hashtable 将一个或多个键映射到此值，则返回 true。
Enumeration elements()
返回此哈希表中的值的枚举。
Enumeration keys()
返回此哈希表中的键的枚举。
Set keySet()
返回此映射中包含的键的 Set 视图。
V get(Object key)
返回指定键所映射到的值，如果此映射不包含此键的映射，则返回 null. 更确切地讲，如果此映射包含满足 (key.equals(k)) 的从键 k 到值 v 的映射，则此方法返回 v；否则，返回 null。
V put(K key, V value)
将指定 key 映射到此哈希表中的指定 value。
java.util.Date
Date()
分配 Date 对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
Date(long date)
分配 Date 对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。
boolean after(Date when)
测试此日期是否在指定日期之后。
boolean before(Date when)
测试此日期是否在指定日期之前。
Properties
Properties()
创建一个无默认值的空属性列表。
Properties(Properties defaults)
创建一个带有指定默认值的空属性列表。
String getProperty(String key)
用指定的键在此属性列表中搜索属性。
String getProperty(String key, String defaultValue)
用指定的键在属性列表中搜索属性。
void load(InputStream inStream)
从输入流中读取属性列表（键和元素对）。
void load(Reader reader)
按简单的面向行的格式从输入字符流中读取属性列表（键和元素对）。
Object setProperty(String key, String value)
调用 Hashtable 的方法 put。
void store(OutputStream out, String comments)
以适合使用 load(InputStream) 方法加载到 Properties 表中的格式，将此 Properties 表中的属性列表（键和元素对）写入输出流。
StringTokenizer
StringTokenizer(String str)
为指定字符串构造一个 string tokenizer。
StringTokenizer(String str, String delim)
为指定字符串构造一个 string tokenizer。
int countTokens()
计算在生成异常之前可以调用此 tokenizer 的 nextToken 方法的次数。
boolean hasMoreElements()
返回与 hasMoreTokens 方法相同的值。
boolean hasMoreTokens()
测试此 tokenizer 的字符串中是否还有更多的可用标记。
Object nextElement()
除了其声明返回值是 Object 而不是 String 之外，它返回与 nextToken 方法相同的值。
String nextToken()
返回此 string tokenizer 的下一个标记。
String nextToken(String delim)
返回此 string tokenizer 的字符串中的下一个标记。
Vector
Vector()
构造一个空向量，使其内部数据数组的大小为 10，其标准容量增量为零。
Vector(Collection<? extends E> c)
构造一个包含指定 collection 中的元素的向量，这些元素按其 collection 的迭代器返回元素的顺序排列。
Vector(int initialCapacity)
使用指定的初始容量和等于零的容量增量构造一个空向量。
boolean add(E e)
将指定元素添加到此向量的末尾。
void add(int index, E element)
在此向量的指定位置插入指定的元素
int capacity()
返回此向量的当前容量。
void clear()
从此向量中移除所有元素。
boolean contains(Object o)
如果此向量包含指定的元素，则返回 true。
boolean containsAll(Collection<?> c)
如果此向量包含指定 Collection 中的所有元素，则返回 true。
E elementAt(int index)
返回指定索引处的组件。
Enumeration elements()
返回此向量的组件的枚举。
E get(int index)
返回向量中指定位置的元素。
E set(int index, E element)
用指定的元素替换此向量中指定位置处的元素。
int size()
返回此向量中的组件数。
java.sql.Date
Date(long date)
使用给定毫秒时间值构造一个 Date 对象。
void setTime(long date)
使用给定毫秒时间值设置现有 Date 对象。
String toString()
格式化日期转义形式 yyyy-mm-dd 的日期。
static Date valueOf(String s)
将 JDBC 日期转义形式的字符串转换成 Date 值。
Time
Time(long time)
使用毫秒时间值构造 Time 对象。
static Time valueOf(String s)
将使用 JDBC 时间转义格式的字符串转换为 Time 值。
Timestamp
Timestamp(long time)
使用毫秒时间值构造 Timestamp 对象。
int getNanos()
获取此 Timestamp 对象的 nanos 值。
long getTime()
返回此 Timestamp 对象表示的自 1970 年 1 月 1 日 00:00:00 GMT 以来的毫秒数。
void setNanos(int n)
将此 Timestamp 对象的 nanos 字段设置为给定值。
void setTime(long time)
设置此 Timestamp 对象，以表示 1970 年 1 月 1 日 00:00:00 GMT 以后 time 毫秒的时间点。
static Timestamp valueOf(String s)
将使用 JDBC 时间戳转义格式的 String 对象转换为 Timestamp 值。
DriverManager
static Connection getConnection(String url)
试图建立到给定数据库 URL 的连接。
static Connection getConnection(String url, Properties info)
试图建立到给定数据库 URL 的连接。
static Connection getConnection(String url, String user, String password)
试图建立到给定数据库 URL 的连接。
Connection
Statement createStatement()
创建一个 Statement 对象来将 SQL 语句发送到数据库。
boolean getAutoCommit()
获取此 Connection 对象的当前自动提交模式。
void close()
立即释放此 Connection 对象的数据库和 JDBC 资源，而不是等待它们被自动释放。
void commit()
使所有上一次提交/回滚后进行的更改成为持久更改，并释放此 Connection 对象当前持有的所有数据库锁。
PreparedStatement prepareStatement(String sql)
创建一个 PreparedStatement 对象来将参数化的 SQL 语句发送到数据库。
void setAutoCommit(boolean autoCommit)
将此连接的自动提交模式设置为给定状态。
void rollback()
取消在当前事务中进行的所有更改，并释放此 Connection 对象当前持有的所有数据库锁。
Statement
boolean execute(String sql)
执行给定的 SQL 语句，该语句可能返回多个结果。
ResultSet executeQuery(String sql)
执行给定的 SQL 语句，该语句返回单个 ResultSet 对象。
int executeUpdate(String sql)
执行给定 SQL 语句，该语句可能为 INSERT、UPDATE 或 DELETE 语句，或者不返回任何内容的 SQL 语句（如 SQL DDL 语句）。
void close()
立即释放此 Statement 对象的数据库和 JDBC 资源，而不是等待该对象自动关闭时发生此操作。
PreparedStatement
boolean execute()
在此 PreparedStatement 对象中执行 SQL 语句，该语句可以是任何种类的 SQL 语句。
ResultSet executeQuery()
在此 PreparedStatement 对象中执行 SQL 查询，并返回该查询生成的 ResultSet 对象。
int executeUpdate()
在此 PreparedStatement 对象中执行 SQL 语句，该语句必须是一个 SQL 数据操作语言（Data Manipulation Language，DML）语句，比如 INSERT、UPDATE 或 DELETE 语句；或者是无返回内容的 SQL 语句，比如 DDL 语句。
void setDate(int parameterIndex, Date x)
使用运行应用程序的虚拟机的默认时区将指定参数设置为给定 java.sql.Date 值。
void setDate(int parameterIndex, Date x, Calendar cal)
使用给定的 Calendar 对象将指定参数设置为给定 java.sql.Date 值。
void setDouble(int parameterIndex, double x)
将指定参数设置为给定 Java double 值。
void setFloat(int parameterIndex, float x)
将指定参数设置为给定 Java REAL 值。
void setInt(int parameterIndex, int x)
将指定参数设置为给定 Java int 值。
void setLong(int parameterIndex, long x)
将指定参数设置为给定 Java long 值。
void setString(int parameterIndex, String x)
将指定参数设置为给定 Java String 值。
void setTime(int parameterIndex, Time x)
将指定参数设置为给定 java.sql.Time 值。
ResultSet
void close()
立即释放此 ResultSet 对象的数据库和 JDBC 资源，而不是等待该对象自动关闭时发生此操作。
Blob getBlob(int columnIndex)
以 Java 编程语言中 Blob 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Blob getBlob(String columnLabel)
以 Java 编程语言中 Blob 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
boolean getBoolean(int columnIndex)
以 Java 编程语言中 boolean 的形式获取此 ResultSet 对象的当前行中指定列的值。
boolean getBoolean(String columnLabel)
以 Java 编程语言中 boolean 的形式获取此 ResultSet 对象的当前行中指定列的值。
byte getByte(int columnIndex)
以 Java 编程语言中 byte 的形式获取此 ResultSet 对象的当前行中指定列的值。
byte getByte(String columnLabel)
以 Java 编程语言中 byte 的形式获取此 ResultSet 对象的当前行中指定列的值。
byte[] getBytes(int columnIndex)
以 Java 编程语言中 byte 数组的形式获取此 ResultSet 对象的当前行中指定列的值。
byte[] getBytes(String columnLabel)
以 Java 编程语言中 byte 数组的形式获取此 ResultSet 对象的当前行中指定列的值。
Reader getCharacterStream(int columnIndex)
以 java.io.Reader 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Reader getCharacterStream(String columnLabel)
以 java.io.Reader 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Clob getClob(int columnIndex)
以 Java 编程语言中 Clob 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Clob getClob(String columnLabel)
以 Java 编程语言中 Clob 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
int getConcurrency()
获取此 ResultSet 对象的并发模式。
String getCursorName()
获取此 ResultSet 对象使用的 SQL 光标的名称。
Date getDate(int columnIndex)
以 Java 编程语言中 java.sql.Date 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Date getDate(int columnIndex, Calendar cal)
以 Java 编程语言中 java.sql.Date 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Date getDate(String columnLabel)
以 Java 编程语言中的 java.sql.Date 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
Date getDate(String columnLabel, Calendar cal)
以 Java 编程语言中 java.sql.Date 对象的形式获取此 ResultSet 对象的当前行中指定列的值。
double getDouble(int columnIndex)
以 Java 编程语言中 double 的形式获取此 ResultSet 对象的当前行中指定列的值。
double getDouble(String columnLabel)
以 Java 编程语言中 double 的形式获取此 ResultSet 对象的当前行中指定列的值。
int getInt(int columnIndex)
以 Java 编程语言中 int 的形式获取此 ResultSet 对象的当前行中指定列的值。
int getInt(String columnLabel)
以 Java 编程语言中 int 的形式获取此 ResultSet 对象的当前行中指定列的值。
long getLong(int columnIndex)
以 Java 编程语言中 long 的形式获取此 ResultSet 对象的当前行中指定列的值。
long getLong(String columnLabel)
以 Java 编程语言中 long 的形式获取此 ResultSet 对象的当前行中指定列的值。
boolean next()
将光标从当前位置向前移一行。
boolean previous()
将光标移动到此 ResultSet 对象的上一行。
File
File(String pathname)
通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。
boolean delete()
删除此抽象路径名表示的文件或目录。
boolean exists()
测试此抽象路径名表示的文件或目录是否存在。
File getAbsoluteFile()
返回此抽象路径名的绝对路径名形式。
String getAbsolutePath()
返回此抽象路径名的绝对路径名字符串。
FileInputStream
FileInputStream(File file)
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。
FileInputStream(String name)
通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。
int read(byte[] b)
从此输入流中将最多 b.length 个字节的数据读入一个 byte 数组中。
int read(byte[] b, int off, int len)
从此输入流中将最多 len 个字节的数据读入一个 byte 数组中。
void close()
关闭此文件输入流并释放与此流有关的所有系统资源。
FileOutputStream
FileOutputStream(File file)
创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(File file, boolean append)
创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(String name)
创建一个向具有指定名称的文件中写入数据的输出文件流。
FileOutputStream(String name, boolean append)
创建一个向具有指定 name 的文件中写入数据的输出文件流。
void close()
关闭此文件输出流并释放与此流有关的所有系统资源。
void write(byte[] b)
将 b.length 个字节从指定 byte 数组写入此文件输出流中。
void write(byte[] b, int off, int len)
将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此文件输出流。
FileReader
FileReader(File file)
在给定从中读取数据的 File 的情况下创建一个新 FileReader。
FileReader(String fileName)
在给定从中读取数据的文件名的情况下创建一个新 FileReader。
BufferedReader
BufferedReader(Reader in)
创建一个使用默认大小输入缓冲区的缓冲字符输入流。
String readLine()
读取一个文本行。
void close()
关闭该流并释放与之关联的所有资源。
第一天知识点
JAVA工具可以开发几类程序
1.Applet 网页嵌入小程序(宿主 IE)
流行的替代技术
flash,JS FrameWork(jquery,extjs…)
2.Application 独立应用程序，跨平台的中间件(Weblogic,WebSphere,Tomcat等)或者界面开发常用(Oracle安装程序，网络监控工具等)(图形界面类库awt,swing,swt)
独立程序入库函数是main(String[] args) 不是其他main函数，例如main(int i)
3.jsp,servlet,webservice,EJB
企业事业及政府常用的Java开发技术，涉及OA办公系统，ERP系统，网站等
4.Android APP
安卓手机应用开发技术
开发工具
IDE-Eclispe,netbeans,IDEJ
ant(build.xml),maven类似c语言的make
Ant build.xml文件
<?xml version="1.0" encoding="gb2312"?>
<path id="classpath"><fileset dir="${lib}"><include name="**/*.jar"/></fileset><fileset dir="${extlib}"><include name="**/*.jar"/></fileset><fileset dir="${javahome}/lib"><include name="**/*.jar"/></fileset><pathelement path="${classes}"/>
</path><target name="clean" depends=""><delete dir="${classes}/com"/>
</target><target name="compile" depends=""><javac srcdir="${src}" destdir="${classes}" classpathref="classpath" encoding="UTF-8"/>
</target>
熟练掌握JAVA常用类 String,StringBuilder,Collection,Vector,HashMap,List,Itertor,Integer,Thread,Socket等 J2EE与Corba技术参照 DCOM，DCOM+ 事务服务，命名服务，分布并行计算等 Corba,www.omg.org Java工具 javac 编译工具 java 虚拟机运行工具 jar 压缩打包工具 keytool 安全方面密钥管理工具 RSA非对称加密,DES对称加密 Java类加载器树状结构
类加载器寻找Class时，首先在自己所在的类加载器中寻找，如果未找到，则选择其类加载器的父类加载器，以此类推，直到找到根的类加载器为止，
不可以已跨域分支寻找。
Class版本校验
向下兼容
Javac 1.5 Test.java ->Test.class
Java 1.4 java Test不可以运行
Javac 1.4 Test.java->Test.class
java 1.5可以运行
简单JVM内存结构
JDK安装
1、安装jdk-7u11-windows-x64.exe到D:/jdk1.7.1
2、配置环境变量JAVA_HOME=d:/jdk1.7.1
3、配置环境变量PATH,操作系统一般都已经配置了PATH环境变量，在其后追加;%JAVA_HOME%/bin即可
4、配置环境变量CLASSPATH=.;%JAVA_HOME%/lib/dt.jar;%JAVA_HOME%/lib/tools.jar
命令行例程
1、编写java源文件
public class MyInfo
{
public static void main(String[] args)
{
System.out.println(“姓名：志玲”);
System.out.println(“年龄：38”);
System.out.println(“籍贯：台湾”);
}
}
2、编译MyInfo.java
javac MyInfo.java
3、运行MyInfo
java MyInfo
Eclipse例程
1、新建Java Project类型项目
2、新建Class
3、添加代码
4、运行测试
上机问题列表
1、JDK环境变量设置错误
JAVA_HOME一定指向JDK安装目录，而不是JRE目录
如
2、PATH环境变量未包含%JAVA_HOME%/bin，以致java,javac无法使用
3、CLASSPATH未设置当前目录(.)
CLASSPATH=.;%JAVA_HOME%/lib/dt.jar;%JAVA_HOME%/lib/tools.jar
4、环境变量以及Java代码中出现中文字符问题
5、已知扩展文件名隐藏问题导致Test.java.txt显示为Test.java
第二天知识点
数据类型
基本数据类型，int,short,char,long,float,boolean
引用数据类型, String,Integer,Float,Long,Date,TimeStamp等
int的封装类 Integer
float的封装类 Float
标志符定义
不可使用关键字定义变量名或类名
关键字解释:
abstract定义抽象类和抽象方法
public abstract Animal{
public int countLegs()
{
return 4;
}
public abstract void run();
}
native定义本地调用方法
Runtime.exec(“ipconfig”);
public class GetIp
{
public native String getIp()
{
//invoke os dll
}
}
static静态类成员变量或者静态方法声明
public class Test{
public static String os=“Window7”;
public String machine = “HP”;
public static void main(String[] args)
{
System.out.println(Test.os);
Test t = new Test();
System.out.println(t.machine);
}
}
break,中断循环体；contine，中断本次循环，其他循环继续执行
public class Test{
public static void main(String[] args)
{
for(int pos=0;pos<100;pos++)
{
if(pos == 10)
break;
System.out.println(“循环执行第”+pos+“次”)
}
System.out.println("#################################");
for(int pos=0;pos<20;pos++)
{
if(pos == 10)
continue;
System.out.println(“循环执行第”+pos+“次”)
}
}
}
super代表父对象，this代表本对象
public class Test extends Object
{
public Test()
{
super();//调用Object的构造函数
System.out.println(super.toString()));//调用Object对象toString函数
System.out.println(this.hashCode());//调用Test对象的hashCode函数
}
public static void main(String[] args)
{
new Test();
}
}
try,catch,finally异常捕捉
import java.io.*;
publicclass MyInfo {
publicfloatsalary = 1000;
publicfloatavgSlry = 980;
public MyInfo()
{super();System.out.println(super.toString());
}
/*** @param args*/
publicstaticvoid main(String[] args) {FileInputStream fis = null;try{//try语句块是我们设计的业务逻辑//fis打开文件句柄fis = new FileInputStream("d:/1.xml");intbyZero = 1/0;}catch(Exception e){//catch语句块是出现异常时，我们需要如何处理异常情况e.printStackTrace();}finally{//finally语句块是一定执行的业务逻辑try{//这里关闭文件句柄fis.close();}catch(Exception ee){}System.out.println("release resource");}
}
}
instanceof判断对象是否是某类的实例
importjava.io.FileInputStream;
publicclass MyInfo {
publicfloatsalary = 1000;
publicfloatavgSlry = 980;
public MyInfo()
{super();System.out.println(super.toString());
}
/*** @param args*/
publicstaticvoid main(String[] args) {MyInfo my = new MyInfo();System.out.println(my instanceof MyInfo);System.out.println(my instanceofObject);
}
}
public,protected,private,extends,implements,synchronized
面向对象章节介绍
throw,throws
异常处理章节介绍
变量名定义一般使用英文单词定义，如果单词太长使用其辅音定义
int salary;
int slry
关键字例程
abstract
publicabstractclass MyInfo {
publicabstract String getSalary();/*** @param args*/
publicstaticvoid main(String[] args) {// TODO Auto-generated method stub//出错，抽象方法不可以被实例化MyInfo my = newMyInfo();
}
}
static
publicclass MyInfo {
publicstaticfloatsalary = 1000;
publicfloatavgSlry = 980;
/**
* @param args
*/
publicstaticvoid main(String[] args) {
//通过类名引用static变量或方法
System.out.println(MyInfo.salary);
MyInfo my = new MyInfo();
//通过对象或实例引用非static方法
System.out.println(my.avgSlry);
}
}
break,contine
publicclass MyInfo {
publicstaticfloatsalary = 1000;
publicfloatavgSlry = 980;
/**
* @param args
*/
publicstaticvoid main(String[] args) {
for(int pos=0;pos<100;pos++)
{
if(pos == 10)
break;
//中断全部循环
System.out.println(“current pos = “+pos);
}
System.out.println(”###########################”);
//to here
for(int pos=0;pos<13;pos++)
{
if(pos == 10)
continue;
//中断本次循环，下一次循环继续执行
System.out.println("current pos = "+pos);
}
}
}
Super
publicclassMyInfo {
publicstaticfloatsalary = 1000;
publicfloatavgSlry = 980;
public MyInfo()
{super();System.out.println(super.toString());
}
/*** @param args*/
publicstaticvoid main(String[] args) {MyInfomy = newMyInfo();
}
}
null
publicclass MyInfo {
publicfloatsalary = 1000;
publicfloatavgSlry = 980;
public MyInfo()
{super();System.out.println(super.toString());
}
/*** @param args*/
publicstaticvoid main(String[] args) {String title = null;System.out.println("hi java"+title);
}
}
finally
import java.io.*;
publicclass MyInfo {
publicfloatsalary = 1000;
publicfloatavgSlry = 980;
public MyInfo()
{super();System.out.println(super.toString());
}
/*** @param args*/
publicstaticvoid main(String[] args) {FileInputStream fis = null;try{fis = new FileInputStream("d:/1.xml");intbyZero = 1/0;}catch(Exception e){e.printStackTrace();}finally{try{fis.close();}catch(Exception ee){}System.out.println("release resource");}
}
}
package
package com.hp.lygov;
publicclass User {
/*** @param args*/
publicstaticvoid main(String[] args) {// TODO Auto-generated method stub}
}
this
package com.hp.lygov;
publicclass User {
private String name = null;
publicvoid setName(String name)
{this.name = name;
}public String getName() {returnname;
}/*** @param args*/
publicstaticvoid main(String[] args) {// TODO Auto-generated method stubUser u = new User();u.setName("hp");System.out.println("Name="+u.getName());
}
}
instanceof
importjava.io.FileInputStream;
publicclass MyInfo {
publicfloatsalary = 1000;
publicfloatavgSlry = 980;
public MyInfo()
{super();System.out.println(super.toString());
}
/*** @param args*/
publicstaticvoid main(String[] args) {MyInfo my = new MyInfo();System.out.println(my instanceof MyInfo);System.out.println(my instanceofObject);
}
}
char int
importjava.io.FileInputStream;
publicclass MyInfo {
publicfloatsalary = 1000;
publicfloatavgSlry = 980;
public MyInfo()
{super();System.out.println(super.toString());
}publicint sumSalary()
{return 0;
}
/*** @param args*/
publicstaticvoid main(String[] args) {charc = (char)68;int age = 19;System.out.println(c+age);System.out.print(c);
}
}
Bit Cal
publicclass MyInfo extends Object{
publicfloatsalary = 1000;
publicfloatavgSlry = 980;
public MyInfo()
{super();System.out.println(super.toString());
}
/*** @param args*/
publicstaticvoid main(String[] args) {int num1 = 0x01;//1//0000 0001int num2 = 0xFF;//255 2^8//1111 1111//1111 1111//1111 1110 //254System.out.println(num1&num2);System.out.println(num1|num2);System.out.println(num1^num2);}
Scanner
import java.util.Scanner;
publicclass MyInfo extends Object{
publicfloatsalary = 1000;
publicfloatavgSlry = 980;
public MyInfo()
{super();System.out.println(super.toString());
}
/*** @param args*/
publicstaticvoid main(String[] args) {Scanner scan = new Scanner(System.in);while(true){String cmd = scan.next();if("exit".equals(cmd))break;System.out.println("You Input:"+cmd);}
}
}
作业
设计一个Java计算器，输入两个操作数后，再输入一个运算符(+,-,,/,%)，程序计算结果并显示结果给用户，
流程：程序启动后输出“欢迎使用JAVA计算器，输入1进入计算模式，输入exit退出程序”，用户输入1后，程序提示用户“请输入第一个操作数:”，用户输入操作数后，程序显示“您输入的第一个操作数是：”+操作数，并提示用户“请输入第二个操作数:”，用户输入操作数后，程序显示“您输入的第二个操作数是：”+操作数，并提示用户“输入运算符(+,-,,/,%其中之一)”，程序计算结果并回显，如果用户再次按1继续进入计算模式。
答案：
import java.util.Scanner;
publicclass JavaCal {
privateboolean isReset = false;
/*** 输出欢迎信息*/
publicvoid welcome()
{System.out.println("欢迎使用JAVA计算器，输入1进入计算模式，输入reset复位，输入exit退出程序");
}/*** 计算输入逻辑,严格控制输入顺序,先输入两个操作数* @param sc*/
publicvoid cal(Scanner sc)
{System.out.println("请输入第一个操作数:");Double d1 = getOneNum(sc);if(isReset){welcome();isReset = false;return;}System.out.println("请输入第二个操作数:");Double d2 = getOneNum(sc);if(isReset){welcome();isReset = false;return;}System.out.println("输入运算符(+,-,*,/,%其中之一):");String op = getOp(sc);if(isReset){welcome();isReset = false;return;}if("+".equals(op)){System.out.println(d1+"+"+d2+"="+(d1+d2));}if("-".equals(op)){System.out.println(d1+"-"+d2+"="+(d1-d2));}if("*".equals(op)){System.out.println(d1+"*"+d2+"="+(d1*d2));}if("/".equals(op)){System.out.println(d1+"/"+d2+"="+(d1/d2));}if("%".equals(op)){int i1 = d1.intValue();int i2 = d2.intValue();System.out.println(i1+"+"+i2+"="+(i1%i2));}
}/*** 使用循环确定一个数，如果输入是非数字提示重复输入* @param sc* @return*/publicDouble getOneNum(Scanner sc)
{while(true){String input = sc.next();if("reset".equals(input)){isReset = true;returnnull;}Double d = getDouble(input);if(d == null){System.out.println("输入的数字格式错误，请重新输入");}elsereturn d;}
}/*** 使用循环确定一个数，如果输入是非数字提示重复输入* @param sc* @return*/public String getOp(Scanner sc)
{while(true){String input = sc.next();if("reset".equals(input)){isReset = true;returnnull;}if("+".equals(input) || "-".equals(input) || "*".equals(input) || "/".equals(input) || "%".equals(input)){return input;}elseSystem.out.println("输入运算符出错，请重新输入(+,-,*,/,%其中之一)");}
}/*** 将参数str转化为Double对象*/
public Double getDouble(String str)
{try{return Double.parseDouble(str);}catch(Exception e){returnnull;}
}/*** @param args*/
publicstaticvoid main(String[] args) {// TODO Auto-generated method stubJavaCal jcal = new JavaCal();jcal.welcome();while(true){Scanner sc = new Scanner(System.in);String input = sc.next();if("exit".equals(input)){System.out.println("再见!");break;}elseif("1".equals(input)){jcal.cal(sc);}else{jcal.welcome();}}
}
}
第三天知识点
If基本语法
注意if语句是否带{}作用域，如果不带{}，if只能对其后一条语句限定
if(true)
System.out.println(“first statement”);
System.out.pritnln(“second statement”);
多条件If语句
If-else语句
注意else子句，带{}与不带{}区别。
多分支if语句
else if子句可以写多个，并且注意其后{}作用域
嵌套if语句
三目条件运算
一般用于赋值语句。
Switch语句
switch中表达式匹配case中常量，则执行case中的语句块直到遇到break结束switch语句的执行，如果没有匹配到任何case中的常量，则执行default子句中语句块。
Switch中常见问题
case子句中没有break;导致逻辑错误。
存在两个相同case子句中常量。
switch语句default子句位置问题
Swith与多分支If的异同
例程
复杂条件下的if选择结构
package cn.hp;
public class YanShi01 {
public static void main(String[ ] args) {
int score1 = 100; //王梁的Java成绩
int score2 = 72; //王梁的音乐成绩
if ( ( score1 > 90 && score2 > 80 )
|| ( score1 == 100 && score2 > 70 ) ) {
System.out.println(“老师说:不错，奖励一个iPhone5！”);
}
}
}
使用if-else结构
package cn.hp;
public class YanShi02 {
public static void main(String[] args) {
int score = 91; //王梁的Java成绩
if (score > 98 ) {
System.out.println(“老师说:不错，奖励一个iPhone5！”);
} else {
System.out.println(“老师说:惩罚当众唱歌！”);
}
}
}
使用多分支if语句
package cn.hp;
public class YanShi03 {
public static void main(String[] args) {
int score = 70; //考试成绩
if ( score >= 90 ) {
System.out.println(“优秀”);
} else if (score >= 80 ) {
System.out.println(“良好”);
} else if (score >= 60 ) {
System.out.println(“中等”);
} else {
System.out.println(“差”);
}
}
}
使用嵌套if控制语句
package cn.hp;
import java.util.*;
public class YanShi05{
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
System.out.print(“请输入比赛成绩（s）：”);
double score = input.nextDouble();
System.out.print(“请输入性别：”);
String gender = input.next();
if(score<=10){
if(gender.equals(“男”)){
System.out.println(“进入男子组决赛！”);
}else if(gender.equals(“女”)){
System.out.println(“进入女子组决赛！”);
}
}else{
System.out.println(“淘汰！”);
}
}
}
使用switch语句
package cn.hp;
public class YanShi06 {
public static void main(String[] args) {
int mingCi = 1;
switch (mingCi) {
case 1:
System.out.println(“参加麻省理工大学组织的1个月夏令营”);
break;
case 2:
System.out.println(“奖励惠普笔记本电脑一部”);
break;
case 3:
System.out.println(“奖励移动硬盘一个”);
break;
default:
System.out.println("没有任何奖励 ");
}
}
}
作业
田忌赛马：计算机程序代表田忌，用户代表齐王，田忌的三匹马分别用1，2，3表示，三匹马奔跑的速度关系1〉2〉3。齐王的三匹马分别用A，B，C表示，三匹马奔跑的速度关系是A〉B〉C，这六匹马奔跑的速度关系是A>1>B>2>C>3。现在进行赛马比赛，双方各自挑选自己的一匹赛马与对方进行比赛，参加比赛过的赛马不能再次比赛，比赛是三局两胜制，你设计一个程序代表田忌为比赛选择马匹组合。
流程：程序启动后输出：“欢迎参加田忌赛马比赛，用户输入三匹马的编号,编号之间用空格分隔,例如(A B C)”，程序根据用户输入马匹组合，安排自己参赛组合，力争胜出比赛。
答案
import java.util.Scanner;
publicclass HorseGame
{
privateboolean isExit = false;
/**
* 判断用户输入是否符合齐王马匹编号的组合
* @param input
* @return
*/
publicboolean checkValidInput(String input)
{
//A B C;A C B;B A C;B C A;C A B;C B A
if(“A B C”.equals(input))
returntrue;
if(“A C B”.equals(input))
returntrue;
if(“B A C”.equals(input))
returntrue;
if(“B C A”.equals(input))
returntrue;
if(“C A B”.equals(input))
returntrue;
if(“C B A”.equals(input))
returntrue;
returnfalse;
}
/*** 获取合法马匹组合数组,如果用户输入exit退出系统* @param sc* @return*/
public String[] getHouseDim(Scanner sc)
{while(true){String input = sc.nextLine();if("exit".equals(input)){isExit = true;break;}if(checkValidInput(input)){String dim[] = input.split(" ");return dim;}else{System.out.println("输入错误,请输入 ABC,字母之间用单个空格隔开");}}returnnull;
}/*** 排列赛马的组合,确保胜出* @param args*/public String win(String[] dim)
{String rtn1 = "";String rtn2 = "";for(int i=0;i<dim.length;i++){String str = dim[i];if("A".equals(str)){rtn1 = rtn1 + "3 ";rtn2 = rtn2 + "A ";}if("B".equals(str)){rtn1 = rtn1 + "1 ";rtn2 = rtn2 + "B ";}if("C".equals(str)){rtn1 = rtn1 + "2 ";rtn2 = rtn2 + "C ";}}return rtn2+" 齐王赛马组合\n"+rtn1+" 田忌赛马组合,田忌获胜.....";}publicstaticvoidmain(String[] args)
{HorseGame hg = new HorseGame();System.out.println("欢迎参加田忌赛马比赛，用户输入三匹马的编号,编号之间用空格分隔,例如(A B C)");Scanner sc = new Scanner(System.in);while(true){String[] dim = hg.getHouseDim(sc);if(dim != null){String rtn = hg.win(dim);System.out.println(rtn);}if(hg.isExit)return;}
}
}
import java.util.Scanner;
publicclass Test {
publicstaticvoid main(String[] args) {
Scanner input = new Scanner(System.in);System.out.println("欢迎进入田忌赛马程序，请输入齐王的三局赛马组合（例如：A B C）");while(true){String str = input.nextLine();//检查输入是否正确，如输入格式错误要求重新输入//赛马排列组合只有如下六类情况(A B C)(A C B)(B A C)(B C A)(C A B)(C B A)if("A B C".equals(str) ||"A C B".equals(str) || "B A C".equals(str) || "B C A".equals(str) || "C B A".equals(str) || "C A B".equals(str)){String[] dim = str.split(" ");//3 dim[0]=A dim[1]=B dim[2]=CString rtn1 = "";String rtn2 = "";for(inti=0;i<dim.length;i++){if("A".equals(dim[i])){rtn1 = rtn1 + "A ";rtn2 = rtn2 + "3 ";}if("B".equals(dim[i])){rtn1 = rtn1 + "B ";rtn2 = rtn2 + "1 ";}if("C".equals(dim[i])){rtn1 = rtn1 + "C ";rtn2 = rtn2 + "2 ";}}System.out.println(rtn1+" 齐王赛马组合");System.out.println(rtn2+" 田忌赛马组合，田忌获胜。");}else{if("exit".equals(str)){System.out.println("再见。");break;}System.out.println("输入错误，请重新输入");}}}
}
第四天知识点
while循环语法
while(循环条件)
{
//循环体
}
//先检查条件后执行
示例
int pos = 0;
while(pos<100)
{
System.out.println(“当前循环计数pos=”+pos);
pos++;
}
do-while循环语法
do
{
//循环体
}while(循环条件)
//先执行后检查是否继续循环条件
示例
int pos = 0;
do{
System.out.println(“当前循环计数pos=”+pos);
}while(pos<100)
while,do-while区别
while：先检查条件后执行
do-while：先执行后检查条件
for循环语法
for(语句1;判断语句2;语句3)
{
//循环体
}
示例
for(int i=0;i<100;i++)
{
System.out.println(“当前循环计数i=”+i);
}
注意：for(语句1;判断语句2;语句3)
语句1和语句3可以包含多个赋值语句
for(int i=0,j=100;i<100;i++,j–)
{
System.out.println(“i=”+i+",j="+j);
}
多重循环
while(条件1)
{
while(条件2)
{
//循环体
}
}
for(int i=0;i<100;i++)
{
for(int j=0;j<100;j++)
{
//循环体
}
}
示例：冒泡排序
int numDIm[] = new int[]{1,2,4,5,2,6,7,2,10,31,21};
for(int i=0;i<numDim.length;i++)
{
for(int j=i;j<numDim.length;j++)
{
int swap = 0;
if(numDim[i]>numDim[j])
{
swap = numDim[i];
numDim[i]=numDim[j];
numDim[i]=swap;
}
}
break语句
中断全部循环
for(int i=0;i<100;i++)
{
if(i == 5)
break;
System.out.println(“i=”+i);
}
当i5时循环退出，控制台只打印
i=0
i=1
i=2
i=3
i=4
continue语句
中止本次循环，其他剩余循环继续执行
for(int i=0;i<6;i++)
{
if(i3)
continue;
System.out.println(“i=”+i);
}
当i==3时中止，继续执行i=4,5的循环
控制台打印
i=0
i=1
i=2
i=4
i=5
while循环例程
package cn.hp;
import java.util.Scanner;
public class YanShi08 {
/**
* 如何使用while循环
*/
public static void main(String[] args) {
String answer; //标识是否合格
Scanner input = new Scanner(System.in);
System.out.print(“合格了吗?(y/n)：”);
answer = input.next();
while(!“y”.equals(answer)){
System.out.println(“上午阅读教材！”);
System.out.println(“下午上机编程！\n”);
System.out.print(“合格了吗?(y/n)：”);
answer = input.next();
}
System.out.println(“完成学习任务！”);
}
}
do-while循环例程
package cn.hp;
import java.util.Scanner;
public class YanShi09 {
/**
* 如何使用do-while循环
*/
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String answer = “”; //标识是否合格
do{
System.out.println(“上机编写程序！”);
System.out.print(“合格了吗?(y/n)”);
answer = input.next();
}while(!“y”.equals(answer));
System.out.println(“恭喜你通过了测试！”);
}
}
for循环例程
package cn.hp;
import java.util.*;
public class YanShi10{
/**
* 输入整数，输出其加法表
*/
public static void main(String[] args){
int i, j;
Scanner input = new Scanner(System.in);
System.out.print("请输入一个值： ");
int val = input.nextInt();
System.out.println("根据这个值可以输出以下加法表： ");
for(i = 0, j = val; i <= val; i++, j–){
System.out.println(i + " + " + j + " = " + (i+j));
}
}
}
contine例程
package cn.hp;
import java.util.Scanner;
public class YanShi11{
/**
* 统计80分以上学生比例
/
public static void main(String[] args) {
int score; // 成绩
int total; // 班级总人数
int num = 0; // 成绩大于或等于80分的人数
Scanner input = new Scanner(System.in);
System.out.print("输入班级总人数: ");
total = input.nextInt(); // 输入班级总数
for (int i = 0; i < total; i++) {
System.out.print(“请输入第” + (i + 1) + "位学生的成绩： ");
score = input.nextInt();
if (score < 80) {
continue;
}
num++;
}
System.out.println("80分以上的学生人数是： " + num);
double rate = (double) num / total * 100;
System.out.println(“80分以上的学生所占的比例为：” + rate + “%”);
}
}
作业
1、通过控制台输入一整数n，打印n行数据，第一行一个,第二行两个*,…第n行n个*，结构如下图。
2、通过控制台输入一整数n，打印n行数据，第一行一个*,第二行两个*,…第n行n个*，结果如下图。
3、通过控制台输入一整数n，打印2n行数据，第一行一个,第二行两个*,…第n行n个*，第n+1行n个*，第n+2行n-1个*…第2n行一个,结果如下图
答案
import java.util.Scanner;
publicclass MyInfo
{
publicvoid pic1(int row)
{
for(int i=0;i<row;i++)
{
for(int j=0;j<i+1;j++)
{
System.out.print("*");
}
System.out.println("");}
}publicvoid pic2(int row)
{int k2 = row;for(int i=0;i<row;i++){for(int k=0;k<k2;k++){System.out.print(" ");}k2--;for(int j=0;j<2*i+1;j++){System.out.print("*");}System.out.println("");}
}publicvoid pic3(int row)
{int k2 = row;for(int i=0;i<row;i++){for(int k=0;k<k2;k++){System.out.print(" ");}k2--;for(int j=0;j<i;j++){System.out.print("*");}System.out.println("");}k2 = 0;for(int i=0;i<row;i++){for(int k=0;k<k2;k++){System.out.print(" ");}k2++;for(int j=0;j<row-i;j++){System.out.print("*");}System.out.println("");}
}publicstaticvoid main(String[] args)
{Scanner sc = new Scanner(System.in);intnum = sc.nextInt();MyInfo my = new MyInfo();my.pic3(num);
}
}
第五天知识点
为什么需要数组
用变量保存全班同学的JAVA成绩，需要定义很多变量
float user1Score = 89f;
float user2Score=90f;
float user2Score=80f;
…
如果使用数组只需定义一个数组就可解决问题
float[] javaScore = new float[100];
javaScore[0] = 89f;
javaScore[1] = 90f;
javaScore[2] = 80f;
如何定义数组
java语言使用[]定义数组，[]紧跟数据类型后面或者数组名后面，例如:
String[] dim = new String[10];
String dim[] = new String[10];
都可以。
数组也可定义时赋值，如
String[] dim = new String[]{“Java”,“C”,“VB”};
数组的值为
dim[0] = “Java”,dim[1]=“C”,dim[2]=“VB”;
遍历数组
使用数组下标遍历数组，下标从0开始，不可越界访问。
String[] dim = new String[]{“Java”,“C”,“VB”};
for(int i=0;i<dim.length;i++)
{
System.out.println(i+"+"+dim[i]);
}
//dim.length是数组的长度
数组的操作
添加值
String[] dim = new String [10];
for(int i=0;i<dim.length;i++)
{
dim[i] = i+"";
}
修改值
for(int i=0;i<dim.length;i++)
{
dim[i]=(i+10)+"";
}
删除值
for(int i=0;i<dim.length;i++)
{
dim[i]=null;
}
二维或多维数组
使用[][]或者多个[]定义二维或多维数组。
String[][] dim = new String[2][3];
String[][][] dim = new String[2][3][4];
定义并赋值
String [][] dim = new String[][]{{“JAVA”,“C”,“VB”},{“Android”,“IOS”,“W”}};
多维数组使用嵌套循环存取
for(int i=0;i<dim.length;i++)
{
for(int j=0;j<dim[i].length;j++)
{
System.out.println(“dim[”+i+"]["+j+"]="+dim[i][j]);
}
}
数组操作类Arrays
计算学生平均分
package cn.hp;
import java.util.Scanner;
/**
计算学生平均分
*/
public class YanShi01 {
//第一个演示示例参考答案
public static void main(String[] args) {
int[] scores = new int[5];
//总成绩
float total = 0;
//平均成绩
float avg = 0;Scanner input = new Scanner(System.in);//给出提示System.out.println("请输入5个学生的笔试成绩：");for(int i = 0; i < scores.length; i++) {scores[i] = input.nextInt();}//计算总成绩for (int j = 0; j < scores.length; j++) {//总成绩total += scores[j];}//计算平均成绩avg = total / scores.length;System.out.println("总成绩：" + total);System.out.println("平均分：" + avg);}
}
计算学生最高分最低分
package cn.hp;
import java.util.Scanner;
/**
计算学生最高分最低分
*/
public class YanShi02 {
//第二个演示示例参考答案
public static void main(String[] args) {
int[] scores = new int[5];
//总成绩
float total = 0;
//平均成绩
float avg = 0;
//最高分
int max = scores[0];
//最低分
int min = scores[0];
Scanner input = new Scanner(System.in);//给出提示System.out.println("请输入5个学生的笔试成绩：");for(int i = 0; i < scores.length; i++) {scores[i] = input.nextInt();}//计算总成绩、平均成绩、最高分和最低分for (int j = 0; j < scores.length; j++) {//总成绩total += scores[j];//最高分if (scores[j] > max) {max = scores[j];}//最低分if (scores[j] < min) {min = scores[j];}}//计算平均成绩avg = total / scores.length;System.out.println("总成绩：" + total);System.out.println("最高分：" + max);System.out.println("最低分：" + min);System.out.println("平均分：" + avg);}
}
数组的常用操作
package cn.hp;
/**数组的常用操作
*/
public class YanShi03 {
//第三个演示示例参考答案
public static void main(String[] args){
//数组添加
System.out.println("----数组添加：----");
int index=-1;
String[] phones = {“iPhone4”,“iPhone4S”,“iPhone5”,null};
for(int i=0;i<phones.length;i++){
if(phones[i]==null){
index=i;
break;
}
}
if(index!=-1){
phones[index]=“iPhone5S”;
for(int i=0;i<phones.length;i++){
System.out.println(phones[i]);
}
}else{
System.out.print(“数组已满”);
}
//--------------------------------------------------------------------------------------------------------------------------------
//数组修改
System.out.println("----数组修改：----");
int indexNew=-1;
String[] phoness = {“iPhone3GS经典”,“iPhone4革新”,“iPhone4S变化不大”,“iPhone5”};
for(int i=0;i<phoness.length;i++){
if(phoness[i].equals(“iPhone5”)){
indexNew=i;
break;
}
}
if(indexNew!=-1){
phoness[indexNew]=“iPhone5掉漆”;
for(int i=0;i<phoness.length;i++){
System.out.println(phoness[i]);
}
}else{
System.out.print(“不存在iPhone5”);
}
//--------------------------------------------------------------------------------------------------------------------------------
//数组删除
System.out.println("----数组删除：----");
String[] phonesss = {“iPhone3GS经典”,“iPhone4革新”,“iPhone4S变化不大”,“iPhone5掉漆”};
int indexNewNew=-1;
for(int i=0;i<phonesss.length;i++){
if(phonesss[i].equals(“iPhone3GS经典”)){
indexNewNew=i;
break;
}
}
if(indexNewNew!=-1){
for(int i=indexNewNew;i<phonesss.length-1;i++){
phonesss[i]=phonesss[i+1];
}
phonesss[phonesss.length-1]=null;
}else{
System.out.println(“没有您要删除的内容！”);
}
for(int k = 0;k<phonesss.length;k++){
System.out.println(phonesss[k]);
}
}
}
遍历二维数组
package cn.hp;
public class YanShi04 {
//第四个演示示例参考答案
public static void main(String[] args) {
int [][] array = new int[][]{{80,66},{70,54,98},{77,59}}; //三个班的成绩
int total; //保存总成绩
for(int i = 0; i < array.length; i++) {
String str = (i+1) + “班”;
total = 0; //每次循环到此都将其归0
for(int j = 0; j < array[i].length; j++) {
total += array[i][j]; //成绩叠加
}
System.out.println(str+“总成绩：” + total);
}
}
}
Arrays类的方法
package cn.hp;
import java.util.Arrays;
public class YanShi05 {
//第五个演示示例参考答案
public static void main(String[] args) {
//equals(array1,array2) 的作用是：比较两个数组是否相等
System.out.println("----equals(array1,array2)方法：----");
int [] arr1 = {10,50,40,30};
int [] arr2 = {10,50,40,30};
int [] arr3 = {60,50,85};
System.out.println(Arrays.equals(arr1, arr2)); //判断arr1与arr2的长度及元素是否相等
System.out.println(Arrays.equals(arr1, arr3)); //判断arr1与arr3的长度及元素是否相等
//sort(array) 的作用是：对数组array的元素进行升序排列System.out.println("----sort(array)方法：----");int [][] array = new int[][]{{80,66},{70,54,98},{77,59}};for(int i = 0; i < array.length; i++) {String str = (i+1) + "班";Arrays.sort(array[i]);System.out.println(str+"成绩排序后：");for(int j = 0; j < array[i].length; j++) {System.out.println(array[i][j]);}}//toString(array) 的作用是：将一个数组array转换成一个字符串System.out.println("----toString(array)方法：----");int[] arr = { 10, 50, 40, 30 };Arrays.sort(arr); //将数组按升序排列System.out.println(Arrays.toString(arr)); //将数组arr转换为字符串并输出//fill(array,val) 的作用是：把数组array的所有元素都赋值为valSystem.out.println("----fill(array,val)方法：----");int[] arrs = { 10, 50, 40, 30 }; //初始化整型数组Arrays.fill(arrs, 40); //替换数组元素System.out.println(Arrays.toString(arrs)); //将数组arr转换为字符串并输出//copyOf(array,length) 的作用是：把数组array复制成一个长度为length的新数组System.out.println("----copyOf(array,length)方法：----");int[] arr11 = { 10, 50, 40, 30 };int[] arr22 = Arrays.copyOf(arr11, 3); //将arr11复制成长度为3的新数组arr22System.out.println(Arrays.toString(arr22));int[] arr33 = Arrays.copyOf(arr1, 4); //将arr11复制成长度为4的新数组arr33System.out.println(Arrays.toString(arr33));int[] arr44 = Arrays.copyOf(arr1, 6); //将arr11复制成长度为6的新数组arr44System.out.println(Arrays.toString(arr44));//binarySearch(array, val) 的作用是：查询元素值val在数组array中的下标System.out.println("----binarySearch(array, val)方法：----");int[] arrss = { 10, 50, 40, 30 };Arrays.sort(arrss); //先按升序排列int index=Arrays.binarySearch(arrss, 30); //查找30的下标System.out.println(index);index=Arrays.binarySearch(arrss, 50); //查找50的下标System.out.println(index);
}
}
作业
从控制台输入5个整数，分别存放到整型数组中，计算其最大公约数和最小公倍数。
答案
import java.util.Scanner;
publicclass Test {
publicstaticvoid main(String[] arg)
{
Scanner sc = new Scanner(System.in);
int[] dim = newint[5];
int pos = 0;
//无容错处理，必须正确输入整数
for(int i=0;i<dim.length;i++)
{
dim[i] = sc.nextInt();
}
//取得数组中最大值int max = Integer.MIN_VALUE;for(int i=0;i<dim.length;i++){if(dim[i]>max)max = dim[i];}//从2到最大值依次对数组取模，记录所有公约数String str = "";for(inti=2;i<max;i++){boolean isok = true;for(int k=0;k<dim.length;k++){int mod = dim[k]%i;if(mod != 0)isok = false;}if(isok){str = str + i + " ";}}str = str.trim();if(str.equals(""))System.out.println("无最大公约数");else{//取最后面的公约数是最大公约数pos = str.lastIndexOf(" ");String str2 = str.substring(pos+1);System.out.println("最大公约数="+str2);}//求最小公倍数int min = 0;for(int i=max;true;i++){boolean isok = true;for(int k=0;k<dim.length;k++){int mod = i%dim[k];if(mod != 0)isok = false;}if(isok){min = i;break;}}System.out.println("最小公倍数="+min);
}
}
第六天知识点
万物皆对象
面向对象设计思想
Java语言中的类
类
对象的静态部分
对象的动态部分
对象的属性和方法
Java与面向对象
类的定义
public class Student
{
private String name = null;
private int age;
public void setName(String name)
{
this.name = name;
}
public String getName()
{return name;
}
}
成员变量
对象的创建和使用
定义School类
public class School {
String schoolName; //中心名称
int classNumber; //教室数目
int labNumber; //机房数目
//定义上机实验室的方法
public void showCenter(){System.out.println(schoolName + "培训学员\n" + "配备：" + classNumber + "教" + labNumber + "机");
}
}
创建和使用对象
package cn.jbit.classandobject;
public class InitialSchool {
public static void main(String[] args) {School center = new School();System.out.println("***初始化成员变量前***");center.showCenter();center.schoolName = "洛阳基地"; //给schoolName属性赋值center.classNumber = 10; //给classNumber属性赋值center.labNumber = 10; //给labNumber属性赋值System.out.println("\n***初始化成员变量后***");center.showCenter();
}
}
作业
思考并创建一个银行帐户的类。
答案
import java.util.Date;
publicclass Account {
private String id = null;
private String name = null;
private String no = null;
private Date openDate = null;
privatefloat amount;
public String getId() {
return id;
}
publicvoid setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
publicvoid setName(String name) {
this.name = name;
}
public String getNo() {
return no;
}
publicvoid setNo(String no) {
this.no = no;
}
public Date getOpenDate() {
return openDate;
}
publicvoid setOpenDate(Date openDate) {
this.openDate = openDate;
}
publicfloat getAmount() {
return amount;
}
publicvoid setAmount(float amount) {
this.amount = amount;
}
publicboolean save(float amount)
{returntrue;
}publicboolean get(float amount)
{returntrue;
}
}
第七天知识点
方法定义
返回值+方法名+(参数)+方法体
方法调用
同一个类中方法之间调用，直接用方法名调用
不同类间方法调用，需要定义被调用类的对象，使用对象名+方法名调用
方法使用static方法修饰，可以直接使用类名+方法名调用
方法的定义
方法的返回值
方法的调用
成员变量与局部变量
成员变量与局部变量区别
面向对象的编程
定义并调用狮子类的方法
package cn.jbit.classandobject;
/*
AutoLion.java
电动玩具类
*/
public class AutoLion {
String color = “黄色”; // 颜色/*
- 跑
*/
public void run() {
System.out.println(“正在以0.1米/秒的速度向前奔跑。”);
}
/*
- 叫
*/
public String bark() {
String sound = “大声吼叫”;
return sound;
}
/*
- 获得颜色
*/
public String getColor() {
return color;
}
/*
- 显示狮子特性
*/
public String showLion() {
return “这是一个” + getColor() + “的玩具狮子!”;
// 另一种方式
//return “这是一个” + color + “的玩具狮子!”;
}
}
- 跑
package cn.jbit.classandobject;
/*
- TestLion.java 测试AutoLion的类
*/
public class TestLion {
public static void main(String[] args) {
AutoLion lion = new AutoLion(); //创建AutoLion对象
System.out.println(lion.showLion()); //调用方法显示类信息
lion.run(); //调用跑方法
System.out.println(lion.bark()); //调用叫方法
}
}
Tree
用Java类表示如下树结构，考察同学对Java类理解，如何使用
Java类表示现实世界中事物，把现实世界的事物转化为Java语言表达，对面向对象编程思想加深认识。
publicclassTree {
privateintseqNo = 0;
privateTreeparent = null;
privateTree[] child = null;
publicvoid setSeqNo(int seqNo)
{this.seqNo = seqNo;
}publicint getSeqNo()
{returnseqNo;
}publicvoid setParent(Tree parent)
{this.parent = parent;
}publicvoid setChild(Tree[] child)
{this.child = child;
}publicTree[] getChild()
{returnchild;
}publicvoid printTree(Tree t)
{System.out.println("no="+t.getSeqNo());Tree[] child = t.getChild();if(child != null){for(Tree t2:child){printTree(t2);}}
}publicstaticvoid main(String[] args)
{Tree t1 = newTree();t1.setSeqNo(1);t1.setParent(null);Tree t2 = newTree();t2.setSeqNo(2);t2.setParent(t1);Tree t3 = newTree();t3.setSeqNo(3);t3.setParent(t1);Tree t8 = newTree();t8.setSeqNo(8);t8.setParent(t1);Tree[] child1 = {t2,t3,t8};t1.setChild(child1);Tree t4 = newTree();t4.setSeqNo(4);t4.setParent(t2);Tree t5 = newTree();t5.setSeqNo(5);t5.setParent(t2);Tree[] child2 = {t4,t5};t2.setChild(child2);Tree t6 = newTree();t6.setSeqNo(6);t6.setParent(t8);Tree t7 = newTree();t7.setSeqNo(7);t7.setParent(t8);Tree[] child3 = {t6,t7};t8.setChild(child3);t1.printTree(t1);
}
}
Test
测试类成员变量和局部变量作用域及其在作用域内的优先级，
在成员变量和局部变量共同的作用域内，优先使用局部变量。
package chapter6_1;
publicclassTest {
publicvoid printAge()
{
//成员变量作用内使用成员变量
System.out.println(age);
}
publicvoid setAge(int age)
{//成员变量和局部变量共同作用域内，优先使用局部变量this.age = age;
}
intage = 0;publicstaticvoid main(String[] args)
{Test t = newTest();t.setAge(10);t.printAge();
}
}
AutoLion
package chapter6_1;
publicclassAutoLion {
String color = “黄色”; //颜色
/跑/
publicvoid run(){
System.out.println(“正在以0.1米/秒的速度向前奔跑。”);
}
/叫/
public String bark(){
String sound = “大声吼叫” ;
return sound;
}
/获得颜色/
public String getColor(){
returncolor;
}
/显示狮子特性/
public String showLion(){
return"这是一个" + getColor() + “的玩具狮子!”;
}
publicstatic String getArea()
{
return"非洲"+getLegs();
}
publicstaticint getLegs()
{
return 0;
}
}
ScoreCalc
//体现业务功能细分，计算总分和平均分分别定义两个方法，
//可以优化代码设计，体现面向对象思想
package chapter6_1;
import java.util.Scanner;
publicclass ScoreCalc {
publicint calTotalScore(int[] dim)
{int sum = 0;for(int i=0;i<dim.length;i++)sum = sum+dim[i];System.out.println("sum="+sum);return sum;
}publicint calAvgScore(int[] dim)
{int sum = calTotalScore(dim);int avg = sum/dim.length;System.out.println("avg="+avg);return avg;
}publicvoid showScore()
{}publicstaticvoid main(String args[])
{int[] dim = null;Scanner sc = new Scanner(System.in);System.out.println("请输入课程数:");int len = sc.nextInt();dim = newint[len];for(int i=0;i<dim.length;i++){System.out.println("请输入第"+i+"门成绩:");dim[i]=sc.nextInt();}ScoreCalc scoreCalc = new ScoreCalc();scoreCalc.calTotalScore(dim);scoreCalc.calAvgScore(dim);
}
}
TestReturn
//演示一个方法如何返还多个值，使用返回数组或者对象
package chapter6_1;
publicclassTestReturn {
public WeiHei getSize()
{
WeiHei wh = new WeiHei();
double w = 100;
double h = 200;
wh.setW(w);
wh.setH(h);
return wh;
}
publicstaticvoid main(String[] agrs)
{TestReturn tr = newTestReturn();WeiHei wh = tr.getSize();System.out.println(wh.getW()+","+wh.getH());
}
}
WeiHei
package chapter6_1;
publicclassWeiHei{
doublew = 0;
doubleh = 0;
publicdouble getW() {
returnw;
}
publicvoid setW(double w) {
this.w = w;
}
publicdouble getH() {
returnh;
}
publicvoid setH(double h) {
this.h = h;
}
}
Student
//定义学生类，封装学生的属性并定义显示学生信息的方法
//这可认为是一个数据类
package chapter6;
/**
*
- 学生类
*/
class Student{
publicintid;
public String name;
publicintage;
publicintscore;
publicvoidshowInfo(){System.out.println(id+"\t"+name+"\t"+age+"\t"+score);
}
}
StudentBiz
//操作学生类的业务类，定义许多操作学生类的方法
package chapter6;
/**
*
- 实现学生信息的管理
*/
publicclass StudentBiz {
Student[] students = new Student[30]; // 学生数组/*** 增加学生* @param 一个学生*/
publicvoid addStudent(Student stu){for(int i =0;i<students.length;i++){if(students[i]==null){students[i]=stu;students[i].score=100;break;}}
}
/*** 显示本班的学生信息* */
publicvoid showStudents(){System.out.println("本班学生列表：");for(int i =0;i<students.length;i++){if(students[i]!=null){students[i].showInfo();}}System.out.println();
}
}
TestAdd
//测试类
package chapter6;
importjava.util.Scanner;
publicclassTestAdd {
/*** 调用有参方法*/
publicstaticvoid main(String[] args) {//实例化学生对象Student student1=new Student();student1.id=10;student1.name="王紫";student1.age=18;student1.score=99;student1.showInfo();System.out.println("############");Student student2=new Student();student2.id=11;student2.name="郝田";student2.age=19;student2.score=60;//新增学生对象StudentBiz studentsBiz=new StudentBiz();studentsBiz.addStudent(student1);studentsBiz.addStudent(student2);studentsBiz.showStudents();//显示学生信息System.out.println("############");student1.showInfo();}
}
Cat
//演示构造函数定义，构造函数的参数及使用构造函数创建对象
package chapter6;
publicclassCat {
privatestaticintsid = 0;
private String name;
intid;
public Cat()
{
}
public Cat(Cat c)
{
}
public Cat(String pname,int no)
{
sid = no;
this.name = name;
}
Cat(String name) {
this.name = name;
id = sid++;
}
publicvoid info(){
System.out.println
(“My name is “+name+” No.”+id);
}
publicstaticvoid main(String arg[]){
Cat.sid = 100;
Cat mimi = newCat(“mimi”);
mimi.sid = 2000;
Cat pipi = newCat(“pipi”);
mimi.info();
pipi.info();
Cat c = newCat();
Catc2 = newCat©;
Catc3 = newCat(“cat”,100);
}
}
Book
publicclass Book {
private String no = null;
private String name = null;
private String cbs = null;
private String author = null;
privatefloatprice = 0f;
privateintnum = 0;
public Book(String no,String name,String cbs,String author,float price,int num)
{this.no = no;this.name = name;this.cbs = cbs;this.author = author;this.price = price;this.num = num;
}public String getNo() {returnno;
}publicvoid setNo(String no) {this.no = no;
}public String getName() {returnname;
}publicvoid setName(String name) {this.name = name;
}public String getCbs() {returncbs;
}publicvoid setCbs(String cbs) {this.cbs = cbs;
}public String getAuthor() {returnauthor;
}publicvoid setAuthor(String author) {this.author = author;
}publicfloat getPrice() {returnprice;
}publicvoid setPrice(float price) {this.price = price;
}publicint getNum() {returnnum;
}publicvoid setNum(int num) {this.num = num;
}public String toString()
{String str = "Book[no="+no+",name="+name+",cbs="+cbs+",author="+author+",price="+price+",num="+num;return str;
}publicstaticvoid main(String[] args)
{Book b = new Book("1","Java","Sun","Sun",10,10);System.out.println(b);
}
}
BookMgr
publicclass BookMgr {
private Book[] dim = new Book[10];
privateintpos = 0;
publicvoid addBook(Book book)
{dim[pos]=book;pos++;
}publicvoiddelBook(Book book)
{for(int i=0;i<dim.length;i++){if(dim[i].getNo().equals(book.getNo())){dim[i]=null;}}
}
}
第十天知识点
String…变长参数列表
package chapter7_1;
publicclass Test {
publicvoid
showMsg(String…a)
{
for(int i=0;i<a.length;i++)
System.out.println(a[i]);
}
publicstaticvoid main(String[] args)
{
Test t = new Test();
String[] a = {“A”,“B”};
t.showMsg(“A”,“B”,“C”,“D”);
}
}
main(String[] args)
public class Test
{
public void
showMsg(String…a)
{
}
public static void
main(String[] args)
{
Test t = new Test();
for(int i=0;i<args.length;i++)
System.out.println(args[i]);
}
}
java Test A B C
方法重载
返回值不能定义方法重载
package chapter7_1;
publicclass Test {
publicvoid
showMsg(String…a)
{
}
public String showMsg
(String…a)
{
}
publicstaticvoid
main(String[] args)
{
Test t = new Test();
for(int i=0;i<args.length;i++)
System.out.println(args[i]);
}
}
方法重载示例
package chapter7_1;
publicclass Test {
publicvoid
showMsg(String…a)
{
System.out.println(“Hello String…”);
}
public String showMsg()
{
System.out.println(“Hello Java”);
return"Hello Java";
}
publicstaticvoid
main(String[] args)
{
Test t = new Test();
t.showMsg();
t.showMsg(null);
}
}
参数不明确导致编译错误
package chapter7_1;
publicclass Test {
publicvoid
showMsg(String…a)
{
System.out.println(“Hello String…”);
}
publicvoid
showMsg(Integer i)
{
System.out.println(“Hello Integer”);
}
public String showMsg()
{
System.out.println(“Hello Java”);
return"Hello Java";
}
publicstaticvoid
main(String[] args)
{
Test t = new Test();
t.showMsg();
t.showMsg((Integer)null);
t.showMsg((String[])null);
}
}
多个构造函数
package chapter7_1;
class Penguin2 {
String name = null; //昵称
inthealth = 0; // 健康值
String sex = null; // 性别
public Penguin2(){
System.out.println(“执行构造方法 1”);
}
public Penguin2(String name) {
this();
this.name = “QQ”;
health=10;
sex=“雄”;
System.out.println(“执行构造方法 2”);
}
publicvoid print() {
System.out.println(“企鹅的名字是” + name + “,健康值是”
+ health + “,性别是” + sex);
}
publicstaticvoid main(String[] args)
{
Penguin2 pg2 = new Penguin2(“QQ”);
pg2.print();
}
}
构造函数不能有返回值
package chapter7_1;
publicclass Penguin {
String name = null; //昵称
inthealth = 0; // 健康值
String sex = null; // 性别
publicvoidPenguin() {
health=10;
sex=“雄”;
System.out.println(“执行构造方法”);
}
publicvoid print()
{
System.out.println(“This is one Penguin name=”+
name+",sex="+sex+
“,health=”+health);
}
publicstaticvoid main(String[] args)
{
Penguin p = new Penguin();
p.print();
}
}
JVM添加默认空参构造
package chapter7_1;
publicclass Penguin {
String name = null; //昵称
inthealth = 0; // 健康值
String sex = null; // 性别
publicvoidprint()
{
System.out.println(“This is one Penguin name=”+
name+",sex="+sex+
“,health=”+health);
}
publicstaticvoid main(String[] args)
{
Penguin p = new Penguin();
p.print();
}
}
用户定义构造函数,默认空构造函数被覆盖
package chapter7_1;
publicclass Penguin {
String name = null; //昵称
inthealth = 0; // 健康值
String sex = null; // 性别
public Penguin(String name) {
this.name = name;
health=10;
sex=“雄”;
System.out.println(“执行构造方法”);
}
publicvoid print()
{
System.out.println(“This is one Penguin name=”+
name+",sex="+sex+
“,health=”+health);
}
publicstaticvoid main(String[] args)
{
Penguin p = new Penguin(“QQ”);
p.print();
}
}
传值与传引用
package chapter7_1;
publicclass TestObj {
public String name = “Java”;
public String getName()
{
returnname;
}
publicvoid processTestObj(TestObj to)
{to.name = "Hello Java";
}publicvoid processStr(String str)
{str = "Hello Java";System.out.println("1="+str);
}publicstaticvoid main(String[]args)
{TestObj to = new TestObj();System.out.println(to.name);to.processTestObj(to);System.out.println("2="+to.name);String str = "java";System.out.println(str);to.processStr(str);System.out.println("2="+str);}
}
This示例,指向对象本身
package chapter7_1;
publicclass ThisExam {
privateinti = 0;
ThisExam(int i)
{
this.i = i;
}
ThisExam getObj()
{i++;returnthis;
}publicstaticvoid main(String[] args)
{ThisExam te = new ThisExam(0);ThisExam te3 = new ThisExam(0);ThisExam te2 = te.getObj();ThisExam te4 = te3.getObj();if(te == te2)System.out.println("is same");}
}
This区分同名变量取值问题
package chapter7_1;
publicclass ThisExam {
privateinti = 0;
ThisExam(int i)
{this.i = i;
}publicint getI()
{returni;
}ThisExam getObj()
{i++;returnthis;
}publicstaticvoid main(String[] args)
{
ThisExam te = newThisExam(100);
System.out.println(te.getI());
}
}
static示例
package chapter7_1;
publicclass StaticExam {
publicstatic String name = “Java”;
publicstaticvoid print()
{System.out.println("StaticExam");
}publicstaticvoid main(String[] args)
{
System.out.println(StaticExam.name);
StaticExam.print();
StaticExam se = new StaticExam();
System.out.println(se.name);
se.print();
}
}
静态引入
package chapter7_1;
importstatic chapter7_1.StaticExam.name;
importstatic chapter7_1.StaticExam.print;
importstaticchapter7_1.StaticExam.*;
publicclass StaticImport {
publicstaticvoid testStaticImp()
{
System.out.println(name);
print();
}
publicstaticvoid main(String[] args)
{StaticImport.testStaticImp();
}
}
静态类没有包名无法静态引入
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Scanner;
import chapter6.A1;
importstaticSingle.*;
publicclass Test {
private String[] names = {“A”,“B”};
private String clz = “oracle.jdbc.driver.OracleDriver”;
private String url = “jdbc:oracle:thin:@192.168.174.10:1521:orcl”;
private String usr = “scott”;
private String pwd = “tiger”;
public String str = "java";public Connection getCon()
{try{Class.forName(clz);Connection con = DriverManager.getConnection(url,usr,pwd);return con;}catch(Exception e){e.printStackTrace();}returnnull;
}publicvoid findMax()
{Scanner sc = new Scanner(System.in);int[] score = newint[5];int max = Integer.MIN_VALUE;int min = Integer.MAX_VALUE;for(int i=0;i<score.length;i++){score[i]=sc.nextInt();if(score[i]>max)max = score[i];if(score[i]<min)min = score[i];}System.out.println("min="+min+",max="+max);
}publicvoid incrSalary(int empNo,int salary)
{try{Connection con = getCon();String sql = "update emp set sal=sal+? where empno=?";PreparedStatement pstat = con.prepareStatement(sql);pstat.setInt(1,salary);pstat.setInt(2,empNo);System.out.println("run here.........1");int rtn = pstat.executeUpdate();System.out.println("update rownum="+rtn);System.out.println("run here.........2");pstat.close();con.close();}catch(Exception e){e.printStackTrace();}
}publicvoid sortDim(int[] dim)
{for(int i=0;i<dim.length;i++){for(int j=i+1;j<dim.length;j++){int swap = 0;if(dim[i]>dim[j]){swap = dim[j];dim[j]=dim[i];dim[i]=swap;}}}for(int i=0;i<dim.length;i++)System.out.println(dim[i]);
}publicstaticvoid main(String[] args)
{Test t = new Test();System.out.println(t.getCon());
}
}
Java -cp/javac -d
package edu.lysf;
public class Test
{
public void showMsg
(String…a)
{
for(int i=0;i<a.length;i++)
System.out.println(a[i]);
}
public static void main(String[] args)
{for(int i=0;i<args.length;i++)System.out.println(args[i]);}
}
D:>javac -d . edu/lysf/Test.java
D:>set classpath=
D:>echo %CLASSPATH%
%CLASSPATH%
D:>java -cp . edu.lysf.Test
D:>java -cp . edu.lysf.Test 1 2 3 4
1
2
3
4
D:>
第十一天知识点
测试Private变量
package chapter7_2.p2;
public class
TestPrivate {
private String name = null;
public void setName(String name)
{this.name = name;
}public String getName()
{return name;
}public static void main(String[] args)
{TestPrivate tp = new TestPrivate();tp.name="Hello";System.out.println(tp.name);
}
}
package chapter7_2.p2;
public class TestPrivate2 {
public static void main(String[] args)
{
TestPrivate tp = new TestPrivate();
tp.name=“Hello”;
System.out.println(tp.name);
}
}
测试friendly
package chapter7_2.p2;
public class
TestPrivate {
String name = null;
public void setName(String name)
{this.name = name;
}public String getName()
{return name;
}public static void main(String[] args)
{TestPrivate tp = new TestPrivate();tp.name="Hello";System.out.println(tp.name);
}
}
package chapter7_2.p2;
public class TestPrivate2 {
public static void main(String[] args)
{
TestPrivate tp = new TestPrivate();
tp.name=“Hello”;
System.out.println(tp.name);
}
}
测试protected
package chapter7_2.p2;
public class
TestPrivate {
protected String name = null;
public void setName(String name)
{this.name = name;
}public String getName()
{return name;
}public static void main(String[] args)
{TestPrivate tp = new TestPrivate();tp.name="Hello";System.out.println(tp.name);
}
}
package chapter7_2.p2;
public class TestPrivate2 {
public static void main(String[] args)
{
TestPrivate tp = new TestPrivate();
tp.name=“Hello”;
System.out.println(tp.name);
}
}
继承类protected
package chapter7_2.p3;
public class A1 {
protected String name = “A1”;
public A1()
{System.out.println("A1 constrator");
}public String getName()
{return name;
}
}
package chapter7_2.p2;
import chapter7_2.p3.A1;
public class A3 extends A1{
public void showName()
{
System.out.println(name);
}
}
继承friendly
package chapter7_2.p2;
public class
TestPrivate {
String name = null;
public void setName(String name)
{this.name = name;
}public String getName()
{return name;
}public static void main(String[] args)
{TestPrivate tp = new TestPrivate();tp.name="Hello";System.out.println(tp.name);
}
}
package chapter7_2.p3;
import chapter7_2.p2.TestPrivate;
public class TestPrivate3 extends TestPrivate{
public String getName()
{
return name;
}
public static void main(String[] args)
{
TestPrivate tp = new TestPrivate();
System.out.println(tp.name);
}
}
继承
package chapter7_2.p3;
public class A1 {
protected String name = “A1”;
public A1()
{System.out.println("A1 constrator");
}public String getName()
{return name;
}
}
package chapter7_2.p3;
public class A2 extends A1 {
public A2()
{
System.out.println(“A2 constractor”);
}
}
package chapter7_2.p3;
public class A3 extends A2 {
public A3()
{
System.out.println(“A3 constractor”);
}
public void showName()
{System.out.println(name);
}public static void main(String[] args)
{A3 a3 = new A3();System.out.println(a3.getName());
}
}
方法重写
package chapter7_2.p3;
public class OverWriteMethod {
protected String getInfo()
{
return “OverWriteMethod”;
}
}
package chapter7_2.p3;
public class OverWriteMethodSub extends OverWriteMethod {
public String getInfo()
{
return “OverWriteMethodSub”;
}
}
多态
package chapter7_2.p4;
/**
宠物类，狗狗和企鹅的父类。
@author 北大青鸟
*/
public abstract class Pet {
private String name = “无名氏”;// 昵称
private int health = 100;// 健康值
private int love = 0;// 亲密度/**
- 抽象方法eat(),负责宠物吃饭功能。
*/
public abstract void eat();
/**
- 有参构造方法。
- @param name 昵称
*/
public Pet(){
}
public Pet(String name) {
this.name = name;
}public void setName(String name) {
this.name = name;
}public void setHealth(int health) {
this.health = health;
}public void setLove(int love) {
this.love = love;
}public String getName() {
return name;
}
public int getHealth() {
return health;
}
public int getLove() {
return love;
}
/**- 输出宠物信息。
*/
public void print() {
System.out.println(“宠物的自白：\n我的名字叫” + this.name +
“，健康值是” + this.health + “，和主人的亲密度是”
+ this.love + “。”);
}
}
- 抽象方法eat(),负责宠物吃饭功能。
package chapter7_2.p4;
/**
猫类，宠物的子类。
@author 北大青鸟
*/
public class Cat extends Pet {
private String color;//颜色
public Cat(String name, String color) {
super(name);
this.color = color;
}public void setColor(String color) {
this.color = color;
}public String getColor() {
return color;
}
/**- 实现吃饭方法
*/
public void eat() {
if(getHealth()>=100){
System.out.println(“狗狗”+this.getName() +“吃饱了，不需要喂食了！”);
}else{
this.setHealth(this.getHealth()+4);
System.out.println(“猫咪”+this.getName() + “吃饱啦！体力增加4。”);
}
}
}
package chapter7_2.p4;
- 实现吃饭方法
/**
狗狗类，宠物的子类。
@author 北大青鸟
/
public class Dog extends Pet {
private String strain;// 品种
/*- 有参构造方法。
- @param name 昵称
- @param strain 品种
/
public Dog(String name, String strain) {
super(name);
this.strain = strain;
}
public String getStrain() {
return strain;
}
/* - 重写父类的print方法。
*/
public void print(){
super.print(); //调用父类的print方法
System.out.println("我是一只 " + this.strain + “。”);
}
/**
- 实现吃食方法。
*/
public void eat() {
if(getHealth()>=100){
System.out.println(“狗狗”+this.getName() +“吃饱了，不需要喂食了！”);
}else{
this.setHealth(this.getHealth()+3);
System.out.println(“狗狗”+this.getName() + “吃饱啦！健康值增加3。”);
}
}
}
package chapter7_2.p4;
/**
企鹅类，宠物的子类。
@author 北大青鸟
/
public class Penguin extends Pet {
private String sex;// 性别
/*- 有参构造方法。
- @param name 昵称
- @param sex 性别
/
public Penguin(String name, String sex) {
super(name);
this.sex = sex;
}
public String getSex() {
return sex;
}
/* - 重写父类的print方法。
*/
public void print() {
super.print();
System.out.println("性别是 " + this.sex + “。”);
}
/**
- 实现吃食方法。
*/
public void eat() {
if(getHealth()>=100){
System.out.println(“企鹅”+this.getName() +“吃饱了，不需要喂食了！”);
}else{
this.setHealth(this.getHealth()+5);
System.out.println(“企鹅”+this.getName() + “吃饱啦！健康值增加3。”);
}
}
}
package chapter7_2.p4;
/**
主人类。
@author 北大青鸟
/
public class Master {
private String name = “”;// 主人名字
private int money = 0; // 元宝数
/*- 有参构造方法。
- @param name 主人名字
- @param money 元宝数
*/
public Master(String name, int money) {
this.name = name;
this.money = money;
}
public void setName(String name) {
this.name = name;
}public void setMoney(int money) {
this.money = money;
}public int getMoney() {
return money;
}
public String getName() {
return name;
}
/**- 主人给宠物喂食。
*/
public void feed(Pet pet) {
pet.eat();
}
}
package chapter7_2.p4;
/**
- 测试类，领养宠物并喂食。
- @author 北大青鸟
*/
public class Test {
public static void main(String[] args) {
Dog dog = new Dog(“欧欧”, “雪娜瑞”);
Penguin pgn = new Penguin(“楠楠”, “Q妹”);
Cat cat=new Cat(“Tomcat”,“黄色”);
dog.setHealth(80); //设置健康值，以便正常喂食
pgn.setHealth(80); //设置健康值，以便正常喂食
cat.setHealth(80); //设置健康值，以便正常喂食
Master master=new Master(“王先生”,100);
master.feed(dog);//主人给狗狗喂食
master.feed(pgn);//主人给企鹅喂食
master.feed(cat);//主人给猫喂食
}
}
第十二天知识点
抽象
package com.pb.bird;
public abstract class Bird {
/**
* 飞行
*/
public void fly(){
System.out.println(“弹射飞”);
}
/*** 叫*/
public void shout(){System.out.println("嗷--");
}
public abstract void attack();//攻击
}
package com.pb.bird.impl;
import com.pb.bird.Bird;
/**
分裂鸟
*/
public class SplitBird extends Bird {/**
- 重写攻击方法
*/
public void attack() {
System.out.println(“分裂攻击！”);
}
- 重写攻击方法
}
package com.pb.bird.impl;
import com.pb.bird.Bird;
/**
火箭鸟
*/
public class RocketBird extends Bird {/**
- 重写攻击方法
*/
public void attack() {
System.out.println(“加速冲撞！”);
}
}- 重写攻击方法
package com.pb.bird.test;
import com.pb.bird.Bird;
import com.pb.bird.impl.RocketBird;
import com.pb.bird.impl.SplitBird;
public class Test {
public static void main(String[] args) {/**实例化鸟和鸟的行为的调用 */Bird split_bird =new SplitBird();Bird rocket_bird=new RocketBird();split_bird.fly();split_bird.attack();rocket_bird.fly();rocket_bird.attack();split_bird.shout();rocket_bird.shout();}
}
Final
package edu;
public final class Cat {
private String name = “Cat”;
public String getName() {return name;
}public void setName(String name) {this.name = name;
}
}
package edu;
public class SmallCat extends Cat{
}
package edu;
public class Dog {
public final String name = “Dog”;
public final void eat()
{
System.out.println(“dog eat”);
}
public static void main(String[] args)
{Dog d = new Dog();
}
}
package edu;
public class SmallDog extends Dog{
public void eat()
{
}
}
接口
package edu;
public interface Valuable {
public double getMoney();
}
package edu;
public interface Protectable {
public void beProtected();
}
package edu;
public interface A extends Protectable,Valuable{
}
package edu;
public abstract class Animal {
private String name;
abstract void enjoy();
}
package edu;
public class GoldenMonkey
extends Animal implements
Valuable, Protectable
{
public double getMoney() {
return 10000;
}
public void beProtected() {System.out.println("live in the room");
}public void enjoy() {}public void test() {Valuable v = new GoldenMonkey();v.getMoney();Protectable p = (Protectable)v;p.beProtected();
}public static void main(String[] args)
{GoldenMonkey gm = new GoldenMonkey();gm.test();
}
}
package edu;
public class Hen implements A{
public void m() {}
public void beProtected() {}
public double getMoney() {
return 1.0;
}
public void getMoney() {}
}
单实例设计模式
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Scanner;
import chapter6.A1;
public class Test {
private static Test instance = null;
private Test()
{}
public static Test getInstance()
{if(instance == null){System.out.println("instance create...");instance = new Test();}else{System.out.println("instance exist...");}return instance;
}public static void main(String[] args)
{Test t = Test.getInstance();Test t2 = Test.getInstance();Test t3 = Test.getInstance();System.out.println("t="+t);System.out.println("t2="+t2);System.out.println("t3="+t3);}
}
类对象总结
类
类是什么:类是数据和方法的封装,是用来描述现实世界中的事物的,我们可以理解为一种新的数据类型,扩展了基本数据类型并提供了处理业务逻辑的方法,Java提供我们强大类库JFC,使用JFC可以开发各种底层应用,像线程、网络、数据库、图形等。我们学习Java语言，除了学习Java的基本语法，更重要的是学习Java各式各样的类库。JVM使用ClassLoader加载类，ClassLoader是树状的数据结构，寻找类时依次搜索树的枝叶到根部，如果搜索不到类，报CLassNotFound异常，类通过加载器加载到JVM时，其结构驻留在方法区和常量池。创建对象时，从方法区和常量池中寻找类的信息。
对象
对象是使用类定义的一类变量，按照类的内容(属性及方法)定义一块内存区，它驻留在JVM的Heap中。还有一种说法对象是类的实例，我们可以理解为类是模板或模具，使用这些模板或模具制造出来的个体就是对象。对象应有类的属性和方法。当没有线程引用对象时，垃圾回收线程定期回收对象，释放内存。
成员变量
也称类的属性，是在类中定义的基本数据类型变量或者引用数据类型的变量。变量名不能为Java语言规定的关键字，以字符，特殊字符(_,$)开头，首写字母都要小写。可以使用static修饰，static修饰的变量为静态变量，可以使用类名和对象名引用它，非静态变量只能使用对象名引用。访问修饰符分public,protected,friendly,private,public修饰时其它任何类都可以访问此变量，protected修饰时，只有本类所在包的其他类和本类的子类可以访问，friendly，只能本类所在包的其他类可以访问，private修饰时只能本类内部访问。
成员方法
类中定义的方法或函数，方法处理业务逻辑，是编程设计的重点所在，方法的声明：
访问修饰符+返回类型+方法名称+参数列表+方法体
方法的名称第一字母小写，每个语义单词首字母大小。
方法分静态和非静态，使用关键字static修饰的方法可以使用类名或对象名调用，非静态方法只能使用对象名调用。访问修饰符分public,protected,friendly,private,public修饰时其它任何类都可以访问此方法，protected修饰时，只有本类所在包的其他类和本类的子类可以访问，friendly，只能本类所在包的其他类可以访问，private修饰时只能本类内部访问
方法传参方式
分传值调用和传引用调用，传值调用是将实参的拷贝传入到方法体，方法中对其任何修改，实参不变。传引用调用是将实参的地址传入方法体，方法对其任何修改，都会反映实参上。基本数据类型(int,short,float,double,long ,boolean,char,byte)及String类型都是传值调用，其它引用数据类型都是传引用调用
构造函数
创建对象时使用构造函数，编写类是不定义构造函数，JVM默认创建空参构造，如果用户创建自己的构造函数，JVM不再创建默认构造函数。同一个类中可以创建多个构造函数，构造函数必须与类名同名，没有任何返回值，可以使用访问修饰符修饰，public,protected,friendly,private,public修饰时其它任何类都可以访问此方法，protected修饰时，只有本类所在包的其他类和本类的子类可以访问，friendly，只能本类所在包的其他类可以访问，private修饰时只能本类内部访问。
方法重载
同一类中，定义了方法名相同，返回值相同，参数类型或参数个数不同的几个方法，这几个方法我们称为方法的重载。方法的重载可以提高编程效率，根据传入方法不同的参数执行不同的方法。
例如Math的绝对值方法
方法重写
子类继承父类，重写父类的方法，必须遵循方法名，方法返回值，方法参数都相同，访问控制符只可以放大，不可缩小。再者返回值类型可以缩小，不可放大(子类重写方法返回值可以是父类中方法返回值的子类)。例如：
类继承
子类继承父类的属性及方法，子类可以继续添加自己特有属性及方法，使用子类创建对象时首先需要创建父类的对象，所以在子类的构造函数中必须能够创建父类对象，或者显式创建，或者由JVM隐式地创建。我们编写子类构造函数时必须提高创建父类对象的途径。父类的private成员，不同包间继承时friendly成员，构造函数不能被子类继承。考虑父类是抽象类情况，抽象类不可被实例化，如何子类创建父类的实例。
父类子类属性与方法访问循序：
运行结果
方法多态
通过父类类型作为方法参数，运行时使用子类对象作为实参实现方法的多态，使用方法多态可以精简代码，优化设计。
This
指向本类声明的对象
Super
指向父类的对象，Super三个用途
访问修饰符
构造语句块
package chapter7_2.p3;
public abstract class A1 {
String name = “A1”;
static{
System.out.println("…A1");
}
{System.out.println("---A1");
}public A1()
{System.out.println("A1 constractor");
}protected Object getName()
{return "A1.getName()";
}
}
package chapter7_2.p3;
public class A2 extends A1 {
String name = “A2”;
public A2()
{System.out.println("A2 constracor");
}protected String getName()
{return "A2.getName()";
}public static void main(String[] args)
{A1 a1 = new A2();A2 a2 = new A2();System.out.println("Access Property...");System.out.println(a1.name);System.out.println(a2.name);System.out.println("Access Method...");System.out.println(a1.getName());System.out.println(a2.getName());}
}
Static
静态关键字可修饰属性，方法、静态语句块。
Package
用来组织Java源代码，提供安全访问机制。
Import
向Java源文件中导入类，静态引用静态成员或方法。
抽象类
第十六天知识点
枚举
package chapter8.example8;
public enum Genders {
Male,Female
}
package chapter8.example8;
public class Student {
public Genders sex;
public static void main(String[] args)
{Student t = new Student();//t.sex="Male";t.sex = Genders.Male;if(t.sex==Genders.Male)System.out.println("I am enum type");System.out.println(Genders.Female.ordinal());Integer i = 5;long l = i.longValue();
}
}
Math
package chapter8.example8;
public class MathTest {
public int getRand()
{
int num = (int)(Math.random()*10000);
return num%10+1;
}
public static void main(String[] args)
{MathTest t = new MathTest();System.out.println("Integer ABS="+Math.abs(-5));System.out.println("Float ABS="+Math.abs(-0.5f));System.out.println("Float max="+Math.max(0.4f, 0.6f));for(int i=0;i<10;i++)System.out.println(t.getRand());
}
}
Random
package chapter8.example8;
import java.util.Random;
public class RandomTest {
public static void main(String[] args)
{
Random rand=new Random(); //创建一个Random对象
for(int i=0;i<20;i++){//随机生成20个随机整数，并显示
int num=rand.nextInt(10);//返回下一个伪随机数，整型的
//System.out.println(“第”+(i+1)+“个随机数是：”+num);
}
Random r1 = new Random(100L);
Random r2 = new Random(100L);
System.out.println(“r1=”+r1.nextInt(20));
System.out.println(“r1 2=”+r1.nextInt(20));
System.out.println(“r2=”+r2.nextInt(20));
}
}
String
package chapter8.example8;
public class StringTest {
public static void main(String[] args)
{
String str1 = “Hello Java”;
String str2 = “Hello java”;
if(str1 == str2)
System.out.println(“Is same Object”);
if(str1.equals(str2))
System.out.println("");
if(str1.equalsIgnoreCase(str2))
System.out.println("equalsIgnoreCase");
System.out.println(str1.toUpperCase());
System.out.println(str1.toLowerCase());
}
}
StringBuffer
package chapter8.example4;
import java.util.Scanner;
public class TestInsert {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
//接收数字串，存放于StringBuffer类型的对象中
System.out.print("请输入一串数字： ");
String nums = input.next();
StringBuffer str=new StringBuffer(nums);
//从后往前每隔三位添加逗号
for(int i=str.length()-3;i>0;i=i-3){
str.insert(i,’,’);
}
System.out.print(str);
}
}
Date
package chapter8.example5;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Test {
public static void main(String[] args) {
Date date = new Date(); //创建日期对象
SimpleDateFormat formater = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);//定制日期格式
System.out.println(“当前时间为：”+formater.format(date));
System.out.println(date);
//“2016-08-15”
java.sql.Date sdt = java.sql.Date.valueOf(“2016-08-15”);
System.out.println(sdt);
//"2016-08-01 12:21:01
java.sql.Timestamp ts = java.sql.Timestamp.valueOf(“2016-08-01 12:21:01”);
System.out.println(ts);
//08:45:01
java.sql.Time t = java.sql.Time.valueOf(“08:45:01”);
System.out.println(t);
}
}
Calendar
package chapter8.example6;
import java.util.Calendar;
public class Test {
public static void main(String[] args) {
Calendar t = Calendar.getInstance();
String str = “2016-08-15”;
java.sql.Date dt = java.sql.Date.valueOf(str);
t.setTime(dt);
System.out.println(“今天是”+t.get(Calendar.YEAR)+“年”
+(t.get(Calendar.MONTH)+1)+“月”+t.get(Calendar.DAY_OF_MONTH)+“日”);
System.out.println(“今天是星期”+(t.get(Calendar.DAY_OF_WEEK)-1));
System.out.println(“今天是今年的第”+(t.get(Calendar.DAY_OF_YEAR)));
System.out.println(“今天是今年的第”+(t.get(Calendar.WEEK_OF_YEAR)));
}
}
List
package chapter8;
import java.util.*;
public class TestList {
public static void main(String[] args)
{
List lst = new ArrayList();
for(int i=0;i<10;i++)
{
String str = new String(“Str”+i);
lst.add(str);
lst.add(str);
}
lst.add(null);
lst.add(null);
System.out.println(lst.size());
for(String obj:lst)
{
String str = (String)obj;
System.out.println(str);
}
lst.set(1,“Str02”);
lst.add(2,“Str02_new”);
System.out.println("#######################");
for(Iterator it=lst.iterator();it.hasNext()?
{
Object obj = it.next();
String str = (String)obj;
System.out.println(str);
}
System.out.println(lst.contains(“Str3”));
System.out.println(lst.contains(“Str13”));
System.out.println(lst.get(1));
System.out.println("#######################");
for(int i=0;i<lst.size();i++)
{
System.out.println(lst.get(i));
}
}
}
Set
package chapter8;
import java.util.*;
public class TestSet {
public static void main(String[] args)
{
Set set = new HashSet();
for(int i=0;i<10;i++)
{
String str = new String(“Str”+i);
set.add(str);
set.add(str);
}
for(Object obj:set)
{
System.out.println(obj);
}
set.add(null);
set.add(null);
System.out.println("################");
for(Iterator it=set.iterator();it.hasNext()?
{
Object obj = it.next();
System.out.println(“obj=”+obj);
}
System.out.println("################");
}
}
Map
package chapter8.example7;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.Iterator;
public class Demo {
public static void main(String[] args){ // 1、创建学员对象Student student1 = new Student("李明", "男");Student student2 = new Student("刘丽", "女");// 2、创建保存“键-值对”的集合对象Map students = new HashMap();// 3、把英文名称与学员对象按照“键-值对”的方式存储在HashMap中students.put("Jack", student1);students.put("Rose", student2);// 4、打印英文名System.out.println("键集，学生英文名:");for(Object key: students.keySet()){ System.out.println(key.toString()); }// 5、打印学生详细信息System.out.println("值集，学生详细信息:");for(Object value: students.values()){Student student=(Student)value;System.out.println("姓名："+student.getName()+",性别："+student.getSex());}Student st3 = (Student)students.get("Jack");System.out.println("st3="+st3);System.out.println("containsKey="+students.containsKey("Jack"));System.out.println("containsKey="+students.containsKey("Jack2"));System.out.println("containsKey="+students.containsValue(student1));System.out.println("containsKey="+students.containsValue(st3));if(student1 == st3)System.out.println("is same object");Student st4 = new Student("Java","Java");System.out.println("containsValue="+students.containsValue(st4));students.put("Java",st4);System.out.println("containsValue="+students.containsValue(st4));}
}
Collections
package chapter8.example8.entity;
//示例8代码，学生类
public class Student implements Comparable{
private int number=0; //学号
private String name=""; //学生姓名
private String gender=""; //性别
public int getNumber(){
return number;
}
public void setNumber(int number){
this.number=number;
}
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
public String getGender(){
return gender;
}
public void setGender(String gender){
this.gender=gender;
}
public int compareTo(Object obj){
Student student=(Student)obj;
if(this.number==student.number){
return 0; //如果学号相同，那么两者就是相等的
}else if(this.number>student.getNumber()){
return 1; //如果这个学生的学号大于传入学生的学号
}else{
return -1; //如果这个学生的学号小于传入学生的学号
}
}
}
package chapter8.example8.test;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import chapter8.example8.entity.Student;
public class CollectionsDemo {
/*** @param args*/
public static void main(String[] args) {//示例9代码Student student1=new Student();student1.setNumber(5);Student student2=new Student();student2.setNumber(2);Student student3=new Student();student3.setNumber(1);Student student4=new Student();student4.setNumber(4);ArrayList list=new ArrayList();list.add(student1);list.add(student2);list.add(student3);list.add(student4);System.out.println("-------排序前-------");Iterator iterator=list.iterator();while(iterator.hasNext()){Student stu=(Student)iterator.next();System.out.println(stu.getNumber());}//使用Collections的sort方法对list进行排序System.out.println("-------排序后-------");Collections.sort(list); iterator=list.iterator();while(iterator.hasNext()){Student stu=(Student)iterator.next();System.out.println(stu.getNumber());}
}
}
NetBeans创建图形应用
JAVA API个各种方法相关推荐
- hbase建索引java api_hbase java api样例（版本1.3.1，新API）
hbase版本:1.3.1 目的:HBase新API的使用方法. 尝试并验证了如下几种java api的使用方法. 1.创建表 2.创建表(预分区) 3.单条插入 4.批量插入 5.批量插入(客户端缓 ...
- 【Kotlin】apply 内联扩展函数 ( apply 函数原型 | apply 函数示例 | Kotlin 调用 Java API )
文章目录 I . 内联扩展函数 apply II . Kotlin 调用 Java API III . apply 内联扩展函数示例 ( 调用 Java API 处理图像 ) I . 内联扩展函数 a ...
- 使用HDFS客户端java api读取hadoop集群上的信息
本文介绍使用hdfs java api的配置方法. 1.先解决依赖,pom <dependency><groupId>org.apache.hadoop</groupId ...
- hbase java api样例（版本1.3.1，新API）
hbase版本:1.3.1 目的:HBase新API的使用方法. 尝试并验证了如下几种java api的使用方法. 1.创建表 2.创建表(预分区) 3.单条插入 4.批量插入 5.批量插入(客户端缓 ...
- java search 不能使用方法_ElasticSearch实战系列三: ElasticSearch的JAVA API使用教程
前言 在上一篇中介绍了ElasticSearch实战系列二: ElasticSearch的DSL语句使用教程---图文详解,本篇文章就来讲解下 ElasticSearch 6.x官方Java API的 ...
- Ghidra Java API报NoClassDefFoundError的解决方法
Ghidra是很优秀的逆向工程工具,我也写过一些博客介绍其Java API的用法,例如:Ghidra在Eclipse中新建和运行项目的路径问题_qysh123的专栏-CSDN博客 但是不得不吐槽,其J ...
- Objective-C 字符串拼接函数 多个不同类型的参数拼接到一个字符串 类似于Java中 String.format()方法的原生API
总目录 iOS开发笔记目录 从一无所知到入门 文章目录 需求 Screenshot Code Output 需求 我有多个参数(类型也许不同),需要拼接到一个字符串中. 在Java中有String.f ...
- Elasticsearch8.0版本中Elasticsearch Java API Client客户端的基本使用方法
关于Elasticsearch Java API Client客户端如何连接以及如何对索引和文档进行基本的增删改查操作请查看我的上一篇博文:Elasticsearch RestHighLevelCli ...
- Java API源码在哪里找_详解查看JAVA API及JAVA源码的方法
在java的日常学习中,我们有时候会需要看java的api说明,或者是查看java的源码,使我们更好的了解java,接下来我就来说说如何查看java的api以及java源码 对于java的api,一般 ...
最新文章
- 声波刺激就可长出新骨头？每天只需10分钟，干细胞5天快速分化，芯片装置只需1美元...
- android 注册、登录实现程序
- 希腊字母（mark）
- 帧率ffmepg 摄像头_【WIN电竞】CSGO解除锁帧方法介绍
- 《OpenGL超级宝典》编程环境配置
- P3934-Nephren Ruq Insania【欧拉定理,树状数组】
- LeetCode 466. 统计重复个数（循环节）
- 秒懂HTTPS接口（原理篇）
- golang批量修改文件名称
- 电子邮件营销的十大技巧
- 垃圾收集概述和垃圾收集算法（超详细介绍）
- MTK平台 SIM双卡改成单卡修改
- 服务器ssd硬盘的读写速度,在不同场景下，应该如何正确选购服务器级SSD固态盘呢？...
- 计算机一级网址打不开怎么办,电脑唯独一个网址打不开怎么解决
- java 文件解压缩zip_java解压缩zip文件
- Windows 上帝模式「完全控制面板」的介绍和使用
- 攻略：邮件搬家同一个域名操作步骤，设置邮箱搬家功能的方法
- 离散 排斥或与相容或的区别
- 完美世界跟金亚科技联合宣布推出电视游戏智能盒——完美盒子。
- ctfshow 密码挑战