Programming Methodology in Java 笔记

来源：互联网发布：淘宝主视频制作软件编辑：程序博客网时间：2024/05/23 16:55

发表，是最好的记忆。

第12讲

字符、字符串处理的静态方法( Character类 )：

对于字符：

char ch;

ch=Character.toUpperCase(ch); //返回ch的大写

其它方法诸如 isUpperCase、isLowerCase、isDigit、isLetter

对于字符串：

Java里面，字符串是不可变的。

eg: String str="sadasd";

str=str.toUpperCase()

字符串截取：

s=str.substring(2,5);

字符串倒置：

String result="";

for( int i=0 ; i<str.length(); i++){

result=str.charAt(i) + result;

}

stressed---> desserts 压力甜点

第十三讲

String and Tokenizers

Tokenizers:

import java.util.*;

String line=readline();

String Tokenizer tokenizer = new String Tokenizer(line);

方法有： hasMoreTokens() NextTokens()

默认分隔符是空格。如果想添加其他分隔符，可以给Tokennizer设定新的参数。(设置逗号加空格为新的分隔符)

String Tokenizer tokenizer = new String Tokenizer(line, ", " );

Caesar Cipher (字母表平移，进行加密解密操作) 自上而下的编程思想。

private String encrptCaesar(String str, int key){

String result="";

if (key<0){

key = 26 - ( -key mod 26) ;

}

for(int i=0; i<str.length();i++){

char ch=str.charAt(i);

//自上向下的思想。

result+=result + encrptChar(ch,key);

}

return result;

}

private char encrptChar(char ch, int key ){ //加密 , 解密只需传入 -key

if (Character.isUpperCase(ch)) {

return ( (char) (ch - 'A' + key) mod 26 + 'A' ) ; // 活用mod，精简算法

}

else return ch; //空格等情况

}

第十四讲内存

heap

static variable 静态变量存储在堆上（heap），地址从小到大存储

stack

dynamic variable new方法生成的对象存储在栈上（stack），地址从大到小

经典的2个问题：

1、不new新的对象，直接给p2赋值p1带来的问题：

2、s1、s2位于不同的栈，指向不同的堆。因而匹配字符串不能直接比较

第十五讲 FILES

当基本数据类型的常量被方法调用的时候，调用的是常量的值的拷贝，不会改变常量本身：

primitive: int, char, double, boolean

pass by value

当为对象时被方法调用，传递过去的是对象本身。（即对象的引用）

Object类被调用，传递的是该类在栈中的地址，可以改变该类在栈中储存的堆地址。

pass by object reference

Primitive Class: （Immutable 不可改变，只能传递给new的新对象）

int ---> Int

char ---> Charactor

double -->Double

boolean -->Boolean

文件读取:

import java.io.*;

流程：open/read/close

BufferdReader rd= new BufferdReader(new FileReader("Students.txt") ); //BufferdReader 逐行读取数据

while (true) {

String line = rd.readLine();

if (line==null) break;

println(line);

}

rd.close();

Exception:

throws and catch

try {

code for file access;

}

catch (IOException ex) {

detail the exception;

}

Example: 原则 try 的内容尽可能精简、准确

private BufferedReader openFIle ( String prompt ) {

BufferedReader rd=null;

while( rd == null) {

try {

String name= readline(prompt);

rd=new BufferedReader( new FileReader (name));

} catch IOException {

println("Bad File");

}

return rd;

}

当不知道如何解决异常时。

catch IOException {

throw new ErrorException(ex); // impor acm.util.*;

}

写文件：

1） Open PrintWriter

2） Write

.println

3) close file

Example:

BufferedReader rd = new openFile("Enter FileName");

try{

PrintWriter wr= new PrintWriter( new FileWirter("copy.txt")); //注意，如果有重名，直接覆盖。

while( true){

String line=rd.readline();

if (line == null) break;

println("copy line" + line);

wr.println(line);

}

rd.close();

wr.close();

}

catch IOException {

throw new ErrorException(ex);

}

16讲数组

Array 数组数组同质

int[] myarr=new int[5]; 初始值为0

用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。

static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用--废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。

数组元素交换：

错误方法: (对于基本数据类型，得到的是数值的copy，而不是类的实例的引用)

swap( int x, int y){

using temp.

}

正确方法:

private void swap( int[] arr, int pos1, int pos2) { // 获得引用，修改数值本身

int temp=arr[pos1];

arr[pos1]=arr[pos2];

arr[pos2]=temp;

}

动态数组 ArrayList