java基本程序设计 ------java基础

java基本程序设计
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ComputeAreaWithConsoleInput.java


import java.util.Scanner;
 public class ComputeAreaWithConsoleInput{
   public static void main(String[] arg){

final double PI = 3.1415;//final datatype constantname = value;
Scanner input = new Scanner(System.in);
System.out.print("enter a number for radius: ");
double radius = input.nextDouble();


double area = radius * radius * PI;
 
System.out.println("the area for the circle of radius" + radius + " is " + area );
   }
}
 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------
标识符
必须由字母，_,$开头；但是可以包含数字；描述性命名；


------------------------------------------------------------------------------------------------------------------------------
变量
type name
type：int（32位）  double（64位）  float(32位)  byte  string  char（8位）  long（64位）  short 
区分int和long：long后面存在L；
区分double和float：100.2f 100.2d；而且默认5.0是double类型
科学计数法 1.2345e+2 == 1.2345 * 10^2 == 123.45；


------------------------------------------------------------------------------------------------------------------------------
运算符
+ - * / %
+=  -+  *=  /=  %=


自增、自减：++、--、  a++、++a、a--、--a
a++和++a的差别：运算从左侧开始，a = 4；b = a++； a是5，b是4； c = ++a、 c和a都是5；
int i = 10; int newNum = 10 * i++; i = 11、newNum=100;
int i = 10; int newNum = 10 * (++a); i=11/newNmu=110;


例题：整钱兑换P37。都先换算成最小单位的数字，如可以都换成角，根据元和角的进率相除再%。余数在运算而除数就是个数。
比如把127.56换成多少个100,50.20。10.5.1……


先级：（）[]
! - ++ --
  * / %
  + -
<< >> >>>
< <= > >= instanceof (比较运算符）
== !=         （相等运算符）
a
^ （异或）
|
&&
||
?: （条件运算符）
= += -= *= /= %=（赋值运算符）


所有的二元运算符都是左结合；但是赋值运算符是右结合；
eg：a = b += c = 5 ===== a = ( b += ( c = 5))


对于a mod b
1. a mod b = a mod (-b)
2. a mod b = - (-a mod b)
------------------------------------------------------------------------------------------------------------------------------
类型转换
小转大：隐式转换即可； 大转小：显示 System.out.print((int)1.7);结果是1；
system.out.print((double)1/2);答案是0.5；而system.out.print(1/2)答案是0；
保留两位小数：（int）（tax * 100）/100.0;tax原本为11.853；
如果是double或者float变成int一般是直接舍去小数部分，保留整数
而且类型转换后，被转换的值不变。
把string转成int int i = Integer.parseInt(s);
把string转成double double s = Double.parseDouble(s);
boolean不可转换；Boolean values cannot be cast to other types.
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Math类
引用Math中函数：Math.pow（a，b）=a^b；
计算绝对值函数是Math.abs();
Math类在java.lang中，而所有java.lang包的类都是被隐式导入。但是Scanner需要显示引入
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
char与string
ASCII：A：65；a：97（a比A大）;
‘\u345dE’是错误的。It must have exactly four hex numbers.
char用‘’而string用"";char只能表示一个字符，但是string可以表示一串字符
char的输出结果是带‘’符号的；
int i = '2' + '3'; System.out,print("i is " + i); //i = 101 由于2是50,3是51；不可以只按照数字2和3处理；
char与int的转换是通过ASCII;
转义字符在前面加\；比如\”；还有b t n f r \ ’ ”；
string运用：
   两个字符的连接“+”；如果两个操作数之一是string，则表示连接运算，把非字符串的转换为string；
         eg：String s = "supplement" + 'b' //s = supplementb;
     String s = "supplement" + 2  //s = supplement2;
如果都不是string，表示加法；
 eg：System.out.print（'1'+ 1 +1）; //'1'的ACSII是49.答案是51；
System.out.print（“1”+ 1 +1）;//答案是111；连接了。
·nextLine（）与next（）；
  nextLine读取以按下回车为结束标志的字符串；而next（）则是读取以空白字符结束的字符串；
eg：System.out.print("enter three string");
   String s1 = input.next();
   String s2 = input.next();
   System.out,printIn("s1 is " + s1 );
   System.out,printIn("s2 is " + s2 );
// enter three string：java to java； s1 is java； s2 is to；


    eg：System.out.print("enter three string");
   String s = input.nextLine();
   System.out,printIn("s is " + s );
// enter three string：java to java； s is java to java；


·nextDouble（）接受一个double类型的。nextInt接受一个int类型的。


Scanner input = new Scanner（System.in）；
int value = input.nextInt（）；
String line = input.nextLine（）；
输入34 567（34和567中有回车）
结果是：value是34.line是空
.nextlnt接受到回车停止，不接受回车。.nextLine从回车开始接受，所以输出为空。


如果改成：
Scanner input = new Scanner（new File（“test.txt”））；
int value = input.nextInt（）；
String line = input.nextLine（）；
文件有34 567 空格
则line为‘ ’‘5’‘6’‘7’
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
文档
写一个摘要：解释程序的作用和特点


注释每一个大的部分的解释，行//或者块/*或者使用/**...*/来注释整个方法和类，为了提取出来放在一个文档中，因此必须在类或者方法的开头；


命名习惯：类中每个单词的首字母要大写ComputerArea；
 小写字母命名方法和变量名：如果出现多个单词，则showInputDialog；


适当的缩进和留白；
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
程序的设计错误:
报错往往会因为一个错误而导致下面的行都报错，因为修改程序需要从最开头处进行调试；
三个类型：
syntex error、compile error：
runtime error：检测到一个不能执行的操作；（当程序收到一个不能处理的期望数据时）
logic error：
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
选择
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
boolean
6个比较运算符
boolean lightsOn = true； boolean形变量；
==》产生随机数的方式：
一.在j2se里我们可以使用Math.random()方法来产生一个随机数，这个产生的随机数是0-1之间的一个double，我们可以把他乘以一定的数，比如说乘以100，他就是个100以内的随机，这个在j2me中没有。 


二.在java.util这个包里面提供了一个Random的类，我们可以新建一个Random的对象来产生随机数，他可以产生随机整数、随机float、随机double，随机long，这个也是我们在j2me的程序里经常用的一个取随机数的方法。
在api 中写道 Math.random（） 函数返回的值 大于等于0.0小于1.0所以包括0 不包括1。可以是0.0，不能是1.0 


三.在我们的System类中有一个currentTimeMillis()方法，这个方法返回一个从1970年1月1号0点0分0秒到目前的一个毫秒数，返回类型是long，我们可以拿他作为一个随机数，我们可以拿他对一些数取模，就可以把他限制在一个范围之内啦 


         其实在Random的默认构造方法里也是使用上面第三种方法进行随机数的产生的 
对于方法二中的Random类有以下说明： 


java.util.Random类有两种方式构建方式：带种子和不带种子 


不带种子： 
此种方式将会返回随机的数字，每次运行结果不一样 


public class RandomTest { 
public static void main(String[] args) { 
  java.util.Random r=new java.util.Random(); 
for(int i=0;i<10;i++){ 
    System.out.println(r.nextInt()); 
} 


} 
带种子： 
此种方式，无论程序运行多少次，返回结果都是一样的 


public static void main(String[] args) { 
  java.util.Random r=new java.util.Random(10); 
  for(int i=0;i<10;i++){ 
    System.out.println(r.nextInt()); 
  } 
} 
另外：  


random对象的nextInt(),nextInt(int n)方法的说明： 


int nextInt()  
    返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。  
int nextInt(int n)  
    返回一个伪随机数，它是从此随机数生成器的序列中取出的、在 0（包括）和指定值（不包括）之间均匀分布的 int值。
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------


例题：
   猜生日，在5个4*4的16个数据中，如果生日在其中就yes，不在就no。就可以知道生日的具体日期。因为没输入一个yeshuozheno就是确定一个bit位，而5个bit的取值是31.
   猜彩票：一个数字取彩票的不同位。
int guess = input.nextInt();
int lottery = (int)(Math.random() * 100 );
num1 = guess/10; num2 = guess%10;
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
逻辑运算
 ! && || ^;
 p1 && p2:如果计算完p1不成立，那么不需要计算p2
 p1 || p2  如果计算完p1成立，那么不需要计算p2
当x = 1；（x >= 1） && (x++ > 1) //x = 2;
 （x > 1 ）&&(x++ > 1) //x = 1 ;因为x > 1是错误的，所以执行x++ > 1中自加；
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
switch:
switch 表达式必须能计算出一个char byte short int值。并且必须用（）括住；
value表达式必须是常量，不可以是变量并且必须与switch的类型相同；
每个case必须有一个break；否则继续往下执行；而break会终止整个case语句；
但是break语句不可以用在if条件中，但是可用在循环语句中；
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
条件表达式
if（x > 0）
   y = 1 ;
else
   y = 0;
==> y = (x > 0) ? 1 : 0; 
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
格式化控制台输出：
显示浮点数小数点后两位：（int）（x * 100） / 100.0);
格式标识符：%开头的转换码；  %c -- char ； %d -- int ； %f -- double； %e -- 科学计数法； %b -- Boolean；
eg：double x = 2.0 / 3；
   System.out.printf（“x is %4.2f”，x）；//x = 0.67
4是域宽度，2是精度（小数点后几位），f是转换码；
如果是System.out。printIn（）将无法通过编译
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
循环
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//////while
while（boolean）{
循环体；
循环控制语句（i++）
}
注意：double data = 0；while(data > 5)不可以，因为double浮点数是数据的近似值不可以比较大小。


/////do-while
do{
循环体；
语句组；
}while（boolean）


//////for
for（初始化；循环条件；迭代后的操作）
{
循环体；
}
每次迭代后的动作通常是对控制变量做自增自减
如果i = 0； i<100;和 i=1；i=<100;都是执行100次。
精确计算：有限精度算术的产物：从大到小添加数字没有从小到大添加数字得到的值精准。在大数之前先加小数是减小误差的方式。


--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
break和continue
break结束所在的整个循环；continue结束此次迭代的语句，进行控制变量的操作语句。即该语句后循环体全部停止执行。


----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
方法
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
参数的值传递：顺序匹配；
实参必须与方法签名中定义的参数在次序和数量上匹配，在类型上兼容。比如int给double；
实参不变，形参改变。
方法的调用是一个堆栈的处理，当调用方法的时候会开辟存储空间，调用结束就收回该空间。
模块化的代码：把不同功能进行封装；方便调试；逻辑清晰；可重复使用；
函数重载：方法的修饰符和返回值类型是相同的，只是参数的类型和个数不同。
Math类（三角函数；指数函数；服务方法）
三角函数：Math.sin（参数）即可；两个常量：Math.PI和Math.E。可以直接使用，但是必须有Math.这个前缀。
Math.abs（-2.1） return 2.1；相反数； 


----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
数组
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1.给数组分配空间时，必须通过指定该数组能够存储的元素个数来确定数组的大小；


2.数组的默认值
int 为 0 ； boolean 为false； char为‘\u0000’；


3.数组的复制方法：
1.使用循环语句逐个复制；
2.使用system中的arraycopy方法；
语法：arraycopy（源数组，原数组起始位置，目标数组，目标数组起始位置，总长度）
arraycopy没有给目标数组分配内存空间，复制前必须创建目标数组以及分配给他的内存空间。
3.使用clone
  使用赋值语句复制基本数据类型的变量，但是不可以复制数组；如果采用list2 = list1这种方式实际是讲一个数组的引用赋给另一个数组；既两个数组变量指向同一个数组；
4.方法传递数组。
对于基本数据类型传递的是参数的值，对于数组参数值是数组的引用。即传递的是数组的引用，数据会发生更改。
public static void main（）
{
int[] y = new int[2];
int x = 0 ;
m(x,y);
sytem。out。print（x，y【0】）；
}
public static void m(int x , int[] numbers)
{
x = 1001;
number[0] = 1000;
}
输出： x = 0 ;//没变，不是1001.
number【0】 = 1000；


5.可变长参数
public static void printMax(double...number)
printMax(34,3,56.5,8);
可以对不确定长度的数据当做数组来处理，但是public static void printMax(double[] number)不可。
该可变长参数必须放在最后，并且只能有一个。
6.关于长度length的问题
length是针对数组，声明一个数组想知道该数组的长度；
length（）针对字符串，想知道一个字符串的长度；
size（）针对泛型集合，想知道泛型有多少个元素
如果是二维或者多维数组定义为 int[][] list = new int[][]；那么list.length求的是第一维的长度；如果想求第二维那么使用list[0].length；
7.数组进行传递的时候，int形是不可以转给double形的，不可以隐式转换。会报错
public class practice {
public static void main(String[] args)
{
int[] numbers = new int[10];
displayArray(numbers);
}
public static void displayArray(double[] counts)
{
for(int i = 0 ; i < counts.length; i++)
System.out.println(counts[i]);
}
}


8.Arrays类中有一些函数可以直接使用


java.util.Arrays.binarySearch(数组，key)；
java.util.Arrays.sort(数组)
java.util.Arrays.equals(数组1，数组2)
java.util.Arrays.fill(数组，数据)  //填充




9.数组的一个事例
public class array {


public static void main(String[] args)
{
int[] numbers= {1,2,3,4,5,6,7,8,9,10};
int size = 5;
System.out.println(numbers[size]);

System.out.println(numbers[size++]);
System.out.println(size);
size = 5;
System.out.println(numbers[++size]);
System.out.println(size);
size = 5;
System.out.println(numbers[size--]);
System.out.println(size);
size = 5;
System.out.println(numbers[--size]);
System.out.println(size);
}
}
结果：
6
6
6
7
6
6
4
5
4


10 .动态数组ArrayList
   ·灵活的设置数组的大小；
    输入一个变量n，然后开一个n大小的数组，如果用静态数组是不能开的，因为n 是一个变量不能通过编译，但是用动态数组是可以的。
import java.util.*;
public class array {
public static void main(String[] args) throws Exception
{
Scanner input = new Scanner(System.in);
ArrayList list=new ArrayList(); 
  System.out.println("input a number");  
       int num = input.nextInt();


for(int j = 0 ; j < num;j++)  //开一个num大小的数组
list.add(input.nextInt());  

list.add("2");    //添加元素
list.add("3");  
//使用普通for循环遍历  
for(int a=0;a<list.size();a++)   //只需获取数组的长度就可，list.size（） ，用的list接口。
{  
   System.out.println(list.get(a));  
} 
}


}


   ·常用函数：
        add(Object e);//添加一个元素  
remove(Object o);//移除指定元素  
remove(int index);//移除指定位置上的元素  
  get(int index);//获取指定索引上的元素  


   ·ArrayList实现了List接口，List接口要求对添加的元素进行有序排列，并且可以根据索引访问元素，先添加的元素排在前面，和数组一样，下标从0开始。List接口可以添加重复元素和null值
   ·ArrayList是在util包中；
   ·ArrayList与数组的转换:
例如ArrayList转数组:


ArrayList<String> list=new ArrayList<>();  
 list.add("1");  
 list.add("2");  
   list.add("3");  
Object[] o=list.toArray();  //转换成Object数组  
  String[] s=list.toArray(new String[0]);//转换成指定类型数组,括号里需要一个类型的实例，仅用来获取类型，所以数组大小随意  


数组转List:


String[] s={"1","2","3"};  
List list=Arrays.asList(s);  


  ·导入和不导入的差别
     比如最常用的 ArrayList 这个类导入的话就能这么写
import java.util.ArrayList;
class a
{
ArrayList a1 = new ArrayList();
ArrayList a2 = new ArrayList();
}
  如果不导入的话的话你就的这么写
class b
{
java.util.ArrayList a1 =new new java.util.ArrayList();
java.util.ArrayList a2 =new new java.util.ArrayList();
}


   ·介绍几种遍历方法:


·使用Collection通用的Iterator接口遍历:


ArrayList<String> list=new ArrayList<>();  
        list.add("1");  
        list.add("2");  
        list.add("3");  


        //使用Iterator接口，iterator()这个方法会返回一个Iterator实例  
        Iterator<String> i=list.iterator();  


        while(i.hasNext())
{ //如果有下一个元素  
        String s=i.next();//next()返回元素并将索引指向下一个元素  
        System.out.println(s);//打印元素                           
        //i.remove();删除当前元素  
        }  


·使用List接口特有的listIterator接口遍历,好处是允许向前访问:


ArrayList<String> list=new ArrayList<>();  
list.add("1");  
list.add("2");  
list.add("3");  
//使用ListIterator接口遍历  
ListIterator<String> i=list.listIterator();  


while(i.hasNext())
{  
    String s=i.next();  
    System.out.println(s);  
}  
while(i.hasPrevious())
{
//判断是否有前一个元素  
    String s=i.previous();//访问前一个元素  
    System.out.println(s);  
}  
 
   ·ArrayList 开二维数组；
     public static void main(String[] args) throws Exception
{
System.out.println("Please Input Your String!");
 Scanner sc = new Scanner(System.in);
 String str = sc.nextLine();
 System.out.println();
 String[] sFirst = str.split(";");  //把字符串按照；分开。分成了3段

 double[][] d;


 d = new double[sFirst.length][];


 for(int i=0;i<sFirst.length;i++)
 {   
  String[] sSecond = sFirst[i].split(","); //把“；”分成的小段，在根据“，”分开；
  d[i] = new double[sSecond.length];


  for(int j=0;j<sSecond.length;j++) {
//   d[i][j] = (double)(sSecond[j]);   //(double)*这种不能转换String类型
   d[i][j] = Double.parseDouble(sSecond[j]);   //将字符串转换为double类型
  }
 }


 for(int i=0; i<d.length;i++) {  //取一维的长度
  for(int j=0;j<d[i].length; j++) {   //取二维的长度
   System.out.print(d[i][j]+" ");
  }
  System.out.println();
 }
}


11 public String[] split(String regex)根据给定正则表达式的匹配拆分此字符串
 
   split 方法
将一个字符串分割为子字符串，然后将结果作为字符串数组返回。


stringObj.split([separator，[limit]])


stringObj 
必选项。要被分解的 String 对象或文字。该对象不会被 split 方法修改。


separator 
可选项。字符串或 正则表达式 对象，它标识了分隔字符串时使用的是一个还是多个字符。如果忽
略该选项，返回包含整个字符串的单一元素数组。 


limit
可选项。该值用来限制返回数组中的元素个数。


说明：
split 方法的结果是一个字符串数组，在 stingObj 中每个出现 separator 的位置都要进行分解
。separator 不作为任何数组元素的部分返回。




示例1：
public class SplitDemo {
    
     public static String[] ss = new String[20];


     public SplitDemo() {


         String s = "The rain in Spain falls mainly in the plain.";
         // 在每个空格字符处进行分解。
         ss = s.split(" ");
     }


     public static void main(String[] args) {


         SplitDemo demo = new SplitDemo();
         for (int i = 0; i < ss.length; i++)
             System.out.println(ss[i]);
     }


}


程序结果：
The
rain
in
Spain
falls
mainly
in
the
plain.




示例2：
public class SplitDemo {


     public static String[] ss = new String[20];


     public SplitDemo() {


         String s = "The rain in Spain falls mainly in the plain.";
         // 在每个空格字符处进行分解。
         ss = s.split(" ", 2);
     }


     public static void main(String[] args) {
         SplitDemo demo = new SplitDemo();
         for (int i = 0; i < ss.length; i++)
             System.out.println(ss[i]);
     }


}


程序结果：
The
rain in Spain falls mainly in the plain.




示例3：
public class SplitDemo {


     public static String[] ss = new String[20];


     public SplitDemo() {


         String s = "The rain in Spain falls mainly in the plain.";
         // 在每个空格字符处进行分解。
         ss = s.split(" ", 20);
     }


     public static void main(String[] args) {
         SplitDemo demo = new SplitDemo();
         for (int i = 0; i < ss.length; i++)
             System.out.println(ss[i]);
     }


}


程序结果：
The
rain
in
Spain
falls
mainly
in
the
plain.




示例4：
public class SplitDemo {


     public static void main(String[] args) {


         String value = "192.168.128.33";
         String[] names = value.split(".");
         for (int i = 0; i < names.length; i++) {
             System.out.println(names[i]);
         }


     }
}


运行结果： 


对，没看错！没有任何输出！ 
让我们来看看 split 方法的方法签名吧：


public string[] split(string regex) 
这里的参数的名称是 regex ，也就是 regular expression （正则表达式）。这个参数并不是一个简单的分割用的字符，而是一个正则表达式，看了 split 方法的实现代码就更坚定了我们的信心： 


public string[] split(string regex, int limit) { 
return pattern.compile(regex).split(this, limit); 
} 
split 的实现直接调用的 matcher 类的 split 的方法。读者已经知道，“ . ”在正则表达式中有特殊的含义，因此我们使用的时候必须进行转义。 
只要将
String[] names = value.split(".");
改为
String[] names = value.split("//.");
就可以了。


输出结果：
192
168
128
33 




再加一点儿补充（这是Java帮助文档中的，更清晰一些）：


public String[] split(String regex,int limit)根据匹配给定的正则表达式来拆分此字符串。 
此方法返回的数组包含此字符串的每个子字符串，这些子字符串由另一个匹配给定的表达式的子字符串终止或由字符串结束来终止。数组中的子字符串按它们在此字符串中的顺序排列。如果表达式不匹配输入的任何部分，则结果数组只具有一个元素，即此字符串。 


limit 参数控制模式应用的次数，因此影响结果数组的长度。如果该限制 n 大于 0，则模式将被最多应用 n - 1 次，数组的长度将不会大于 n，而且数组的最后项将包含超出最后匹配的定界符的所有输入。如果 n 为非正，则模式将被应用尽可能多的次数，而且数组可以是任意长度。如果 n 为零，则模式将被应用尽可能多的次数，数组可有任何长度，并且结尾空字符串将被丢弃。 


12.正则表达式 - 语法
正则表达式(regular expression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
eclipse运行出现的问题：
  在运行了一个while（true）后，出现了一直运行无法出来的现象，所以会出现Java(TM) platform SE binary占用几乎全部CPU 的现象；
  一直占用CPU的原因太简单了，用脚趾头都能想到，因为线程一直没有停止。
  为了看到多线程运行的现象，在程序中使用了while(true)语句，导致线程一直在运行，自己以为结果已经出来了。
  后来才发现窗口中一直没有显示“Process finished with exit code 0”的运行结束提示。


------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------


对象和类


------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------


1.基本构造：
 class
{
数据域；
构造函数；
方法；
}
一个类中包含一些数据域；既该类的属性。比如circle中radius为其属性；
·构造函数：
·构造函数必须与该类名字相同
·没有返回类型，也没有void；
·构造方法是创建一个对象使用new操作符时调用的；作用也是初始化对象；
·可以重载；同时如果不主动声明，会有一个默认值。即无参构造方法；


2.一个文件中可以有两个类，但是只能有一个是public的，并且该类的名字与文件同名，既*.java；


3.通过引用变量来访问对象
与数组相同，构造方法可以是：Circle myCircle = new Circle（）；
·访问数据域和方法的方式：myCircle.数据域；.方法名；


4.基本数据类型和引用数据类型的区别
基本数据类型该位置存的就是该数据；而引用数据类型存的是第一个数据的首地址；


5.Data类
·存在默认构造函数和getTime()； toString() ； 函数


java.util.Date data = new java.util.Date();  //创建一个对象
System.out.println(data.getTime());//返回从1970.1.1到现在的秒数
System.out.println(data.toString());   //返回日期和时间的字符串表达式




6.Random类


·在创建一个Random时候，需要指定一个种子或者使用默认的种子。无参构造函数使用流逝的时间作为一个种子。
·如果两个对象的种子相同，会产生相同的随机数列；


java.util.Random random1 = new java.util.Random(3);
System.out.println("random1");
for(int i = 0 ; i<5;i++)
System.out.println(random1.nextInt(1000));

java.util.Random random2 = new java.util.Random(3);
System.out.println("random2");
for(int i = 0 ; i<5;i++)
System.out.println(random1.nextInt(1000));
构造方法：
·+Random（）选取当前时间作为种子；
·+Random（seed：long）//选取特定的种子；


+nextlnt（）：int 返回一个随机整数型值
+nextlnt（n：int）：int  返回一个从0到n之间的随机整数；
+nextlnt（）：double     返回一个从0.0到1.0的随机数
……
·java.Math.Random()实际是在内部调用java.util.Random()的；
·java.util.Random()在调用的时候可以实现和java.Math.Random()一样的功能，而且它有更多的调用方法，相对来说比较灵活；
· 二者都是弱随机数，弱伪随机数PRNG实现 java.util.Random类，默认使用当前时间作为种子，并且采用线性同余法计算下一个随机数；
   强伪随机数RNG实现java.security.SecureRandom类，该类使用临时文件夹中大小，线程休眠时间等的值作为随机数种子




7.GUI组件的框架


public static void main(String[] args)
{
JButton jbtOK = new JButton("OK");
JButton jbtCancel1 = new JButton("Cancel");

JPanel panel1 = new JPanel();
panel1.add(jbtOK);
panel1.add(jbtCancel1);



JFrame frame1 = new JFrame();
frame1.add(panel1);

frame1.setTitle("WINDWO 1 ");
frame1.setSize(200,150);
frame1.setLocation(200,100);
frame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame1.setVisible(true);
}


8.静态变量


·共享数据。声明为静态变量。static。静态变量将数据存储在一个公共地址中。
·事例变量与某个具体的事例是有关的，但是静态变量不是。
  Math就是一个静态的类。
·静态变量的引用可以不声明具体的事例变量，用该类.就可以使用。
·实例变量和实例方法只能再实例方法中使用，但是静态的可以在任何时候使用。
·如何判断一个变量是实例还是静态？
如果一个变量依赖于某个具体的事例，为事例变量。
·静态的函数和数据域是在类加载的时间就加载的，因此不可以存在非静态的方法，实例的数据和变量是在对象被创建的时候才创建的。


11.static和final的区别
  ·final可以修饰：属性，方法，类，局部变量（方法中的变量）
     final修饰的属性的初始化可以在编译期，也可以在运行期，初始化后不能被改变。
     final修饰的属性跟具体对象有关，在运行期初始化的final属性，不同对象可以有不同的值。
     final修饰的属性表明是一个常数（创建后不能被修改）。
     final修饰的方法表示该方法在子类中不能被重写，final修饰的类表示该类不能被继承。
     对于基本类型数据，final会将值变为一个常数（创建后不能被修改）；但是对于对象句柄（亦可称作引用或者指针），final会将句柄变为一个常数（进行声明时，必须将句柄初始化到一个具体的对象。而且不能再将句柄指向另一个对象。但是，对象的本身是可以修改的。这一限制也适用于数组，数组也属于对象，数组本身也是可以修改的。方法参数中的final句柄，意味着在该方法内部，我们不能改变参数句柄指向的实际东西，也就是说在方法内部不能给形参句柄再另外赋值）。
 
 
  ·static可以修饰：属性，方法，代码段，内部类（静态内部类或嵌套内部类）
     static修饰的属性的初始化在编译期（类加载的时候），初始化后能改变。
     static修饰的属性所有对象都只有一个值。
     static修饰的属性强调它们只有一个。
     static修饰的属性、方法、代码段跟该类的具体对象无关，不创建对象也能调用static修饰的属性、方法等
     static和“this、super”势不两立，static跟具体对象无关，而this、super正好跟具体对象有关。
     static不可以修饰局部变量。
 
    ·static final和final static没什么区别，一般static写在前面。
    ·static修饰的属性强调它们只有一个，final修饰的属性表明是一个常数（创建后不能被修改）。static final修饰的属性表示一旦给值，就不可修改，并且可以通过类名访问。
    ·static final也可以修饰方法，表示该方法不能重写，可以在不new对象的情况下调用。


  ·static是静态修饰关键字，可以修饰变量和程序块以及类方法：


·当定义一个static的变量的时候jvm会将将其分配在内存堆上，所有程序对它的引用都会指向这一个地址而不会重新分配内存；


·当修饰一个程序块的时候(也就是直接将代码写在static{...}中)时候，虚拟机就会优先加载静态块中代码，这主要用于系统初始化；


·当修饰一个类方法时候你就可以直接通过类来调用而不需要新建对象。


  ·final可以修饰变量、方法及类：


·当定义一个final变量时，jvm会将其分配到常量池中，程序不可改变其值；


·当修饰一个方法时，该方法在子类中将不能被重写；


·当修饰一个类时，该类不能被继承。


12.静态函数的思考


·静态函数和全局函数类似，区别是文件作用域， 只能在本文件内有效，其他文件无法访问（全局函数可以被同一工程的别的文件使用）。


·静态类不能被实例化，可直接调用静态类的函数，不用创建对象后调用，静态类的函数之间没逻辑上的关联，静态类只是作为一个函数的集合。


9.可见性修饰符
·public：可以在任何地方使用；
·private：同类可以使用
·默认不写的为同包可以使用；


10数据域的封装---private
·用private修饰的为私有数据，在类外的对象是不可以访问该数据的。
·但是如果有客户要读取该数据，可以使用get函数来访问。既返回数据域的值---get为读取器
public returntype getPropertyName（）
如果要返回的是boolean则使用： public boolean isPropertyName（）
·如果要修改该数据，使用set函数----set为修改器
public void setPropertyName（datatype propertyValus）


---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
对对象的思考


---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1.要使一个类成为不可变类，它必须满足：
·所有数据都是私有的
·没有修改器方法
·没有一个访问器方法，它会返回一个指向可变数据域的引用。


2.类的变量和方法在类中以任意顺序出现，但是如果一个变量是基于另个变量基础上定义的，那必须先定义其变量；


3.类变量只能声明一次，但是在一个方法中不同非嵌套块中，可以多次声明相同的变量名


4.如果一个局部变量和一个类变量具有相同的名字，局部变量优先 --- 存在覆盖


5.this引用
·数据域的set方法，经常将数据域名作参数名，在这种情况下，这个数据域在set方法中被隐藏，为了给他设置新值，需要在方法中引用隐藏的数据域名。
静态可以使用类名.静态变量；实例变量必须用this；
·this.i = i；将参数i的值赋给调用对象的数据域的i。
·java要求在构造方法中，this语句要在任何其他语句之前出现；

·this的使用：在构造函数方面；
//构造函数
public BMI(String name , int age, double height , double weight)
{
this.name = name;
this.age = age;
this.height = height;
this.weight = weight;
}

public BMI(String name,double height , double weight)
{
this(name,20,height,weight);
}



6.类的抽象和封装
由于面向对象的特殊性，类的实现和使用是两个不同的步骤，类的实现是使用的时候看不见的，因此需要test程序去测试。
但是测试在main中，可以先编写test程序去搞懂实现程序的实现方式。
而且同一个类中的函数是不需要传递参数的，都可以相互使用。


---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
继承和多态


---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1.使用类对同一类型的对象建模，不同的类也有一些共同的特征，这些共同的特征和行动放在同一个类中，他是可以被共享的，
继承可以让你定义一个通用类，随后扩展成更多特定的类。


2.如果c1扩展自另一个类c2，c2为父类，c1为子类，子类从他的父类中继承可访问的数据域和方法，还可以自己添加新的数据域和方法。


3.public class Circle extends GemetrivObject.显示继承。
如果父类中的数据域是私有的，那么继承后的类也只能通过set或者get函数来访问。因为他们属于不同的类。


4.super：
·用于调用父类的构造方法；
super（） or super（parameters）
super（）调用他的父类的无参构造方法；
super（patameters） 调用与参数匹配的父亲的构造方法；
必须出现在子类构造函数的第一行。显示调用父类构造方法的唯一方式。


public Circle1(double radius,String color,boolean filled)
{
this.radius = radius;
setColor(color);
setFilled(filled);

}
可以写成====》
public Circle1(double radius,String color,boolean filled)
{
super(color,filled);//不可以放在this后。
this.radius = radius;
}


·调用父类的方法；
super.方法名（参数）；
·一般情况，父类的函数是可以直接被子类函数所使用的，不需要明确加super。
·覆盖：如果子类定义和父类一样的函数，相当于重写该函数的功能，在对象调用函数的时候，这时super.方法名（）为调用父类的该函数，直接使用方法名为使用子类中该函数。
·如果Circle的子类想调用Circle的父类也就是GeometricObject中的函数，使用super.super.toString（）这种表达是错误的。
·仅当实例方法是可访问的时候才可以覆盖，也就是父类中的私有函数只和父类有关于子类一点关系都没有，
·静态方法也可以被继承，但是不可以覆盖。如果父类中的静态方法在子类中被重新定义，那么定义在父类中的静态方法将被隐藏。需要显示调用（父类名.静态方法名）

·父类的构造函数是不被继承的，只能有super函数来调用；


5.构造方法链
·构造方法可以调用重载的构造方法或它的父亲的构造方法。如果他们都没有显示的调用，编译器就会自动的将super（）作为构造方法的第一条语句。
public ClassName（）{ //some statement }
public ClassName（）{ supper（）; }


public ClassName（double d）{ //some statement }
public ClassName（double d）{ supper（）; }




·构造任何一个类的实例时，将会调用沿着继承链的所有父类的构造方法。
           当构造一个子类的对象时，子类的构造方法会在完成自己的任务之前，首先调用它的父类的无参构造方法。
 如果父亲的类继承自其它类，那么会先调用其它类的构造方法，直到最后一个构造方法被调用为止。

·最好在编写类的时候为每一个类提供一个显示的无参构造方法，以便于用于扩展。


·子类如果没有构造函数，默认是调用父类的无参构造。如果父类没有显示的无参构造函数，会出现错误。


6.Object类
·java的每个类都源于java.lang.Object类，如果在定义一个类的时候没有指明继承性，那么这个类的父类就是Object。
·toString函数；
·调用一个对象的toString（）会返回一个描述该对象的字符串，默认情况返回一个对象的所属类名，@，和一个该对象的十六进制形式的内存地址组成的字符串。
·一般采用覆盖的方法，重写该类，作为想要的输出。比如一个对象的描述性字符串。
·也可以通过传递一个对象来调用该函数，比如System.out.print（Object）；相当于Object.toString（）；
·一般用于调试程序。
·equals
·默认实现是：
public boolean equals（Object obj）
{return (this == obj) }
·调用语法是：
object1.equals（object2）；
·比较运算符 == 表示比较两个基本数据类型的值是否相同，或者判断两个对象是否具有相同的引用；
·如果想比较两个对象的引用其中的内容是否相同，需要重写该函数，
public boolean equals（Object obj）
{
if( o instanceof Circle)
return radius == ((Circle)o).radius;
else
return false; 
·思考题：


7.覆盖于重载的一个辨析
·覆盖-----输出都是10.0.
        public class array {
public static void main(String[] args)
{
A a  = new A();
a.p(10);
a.p(10.0);
}
class B
{
public void p(double i)
{
System.out.println(i * 2);
}
}
class A extends B
{
public void p(double i)
System.out.println(i);
}
}
        ·覆盖必须参数的签名是相同的；


·重载-------输出分别是10.和 20.0

        public class array {
public static void main(String[] args)
{
A a  = new A();
a.p(10);
a.p(10.0);
}
class B
{
public void p(double i)
{
System.out.println(i * 2);
}
}
class A extends B
{
public void p(int i)
System.out.println(i);
}
} 


8.多态
·一个类实际上是一个类型，分为子类型和父类型；
·子类是它父类的一个特殊化，每个子类的实例都是其父类的实例。
·多态意味着父类的变量可以引用子类型的对象
  ·Circle是GeometriObject的一个子类，因此可以如此传递。
    public static void main(String[] args)
{
displayObject(new Circle(1,"red",false));
}
public static void displayObject(GeometricObject object)
{
System.out.println("   ");
}


9.动态绑定
声明类型和实际类型；Object o = new GeometricObject（）；
·一个变量是必须被声明为某种类型的，o的声明类型就是Object。
·变量的实际类型，是被变量引用的对象的实际类。
·输出是
Animal
          Cat dinning
· 编译的时候是运行声明类型，而执行的时候是执行实际类型。
·属性找编译，方法找运行
·引用变量的声明类型决定了编译时匹配哪个方法，编译器会在编译的时候根据参数类型，参数的个数，和参数的顺序找到匹配方法，一个方法可能在几个子类中都被实现了，java虚拟机在运行时动态绑定方法的实现，又变量的实际类型决定。
public class array 
{
public static void main(String[] args)
{
        Animal animal=new Cat();
        if(animal instanceof Cat)
      System.out.println(animal.name);//Animal
        animal.dinner();//Cat dinning
   
}
}
//父类
  class Animal 
{
    public String name = "Animal";
    public void dinner() 
{
          System.out.println("Animal dinning");
    }
}
//子类
  class Cat extends Animal 
{
               public String name = "Cat";
       public void dinner() 
  {
        System.out.println("Cat dinning");
      }
}
        ·如果o是C1的一个实例，那么也是C2，C3……的实例。当C1是C2子类，C2是C3子类的时候。当调用对象o的一个函数时，会现在C1中找，找到的话就调用，没找到在C2中找。
·输出结果是：
Students
Students
Person


public class array {
public static void main(String[] args)
{
m(new GraduateStudent());
m(new Students());
m(new Person());
}
public static void m(Object x)
{
System.out.println(x.toString());
}

}
class GraduateStudent extends Students
{

}
class Students extends Person
{
public String toString()
{
return "Students";
}
}
class Person extends Object
{
public String toString()
{
return "Person";
}
}


10.对象转换和instanceof运算符





11.protected
·private和protected只能用于类成员的修饰，不可以用于类的修饰。
·protected修饰符允许任何包中的子类或者同一个包中的类访问类成员，但是非同包非子类不可以访问，
·public允许任何类访问该成员
·默认修饰符表示允许同一个包里的任何直接访问类的成员，但是其他包的类不可以访问。
·子类可以覆盖它父类的protected方法，并把他改成public，但是不可以削弱父类的可见性，必须一个方法在父类中是pubilc，在子类中也必须定义为public。


12.防止扩展和覆盖
使用final定义的类是终极类，是不能作为父类的，不可以被继承的，比如Math类，
final放在一个方法的前面，那么这个方法就不能被覆盖。


13.数组线性表ArrayList类
其中包含一些函数
add（o：Object）在末尾加一个元素；
add（index：int，o：Object）在index的位置加一个新元素；---理解为添加
set（index：int，o：Object）设定在特定下标处的元素。----理解为更新
clear（）；删除所有元素
contains（o：Object）如果线性表中包含这个元素返回true
size（）：int 返回线性表中元素的个数；
remove（o：Object）：boolean 从表中删除o元素；
remove（index：int）：boolean 删除指定下标的元素
isEmpty（） ：boolean 如果为空返回true
get（index：int）：Object 返回特定位置的元素
indexOf（o：Object）：int 返回线性表中第一个匹配元素的下标


--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
异常处理
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------


1.try - throw - catch 模块
try{
code to cry；
throw an exception with a throw statement;}
catch(type ex)
{
code to process the exception;
}
·throw类似方法的调用，他调用的是catch块，catch块就像带参数的方法定义，这些参数匹配抛出的值的类型，但是在执行完catch后，不会返回到throw中，而是执行catch块后面的内容；
·catch匹配ex前的参数的类型，匹配到就捕捉，想当于指定一个catch块可以捕获的异常类型。


2.异常处理的优势
它使方法抛出一个异常给他的调用者，这个调用者可以处理该异常，如果没有和这个能力，那么被调用的方法就必须要自己处理异常或者终止该程序，
被调用的方法通常不知道在出错的情况下要做什么，库方法可以检测出错误，但是只有调用者才知道如果出错要做什么，
·优势就是让检测错误从处理错误中分离出来；


3.nextLine()和next()的区别
·nextLine（）方法的结束符只是Enter键，即nextLine（）方法返回的是Enter键之前的所有字符，它是可以得到带空格的字符串的。
·next（）会自动消去有效字符前的空格，只返回输入的字符，不能得到带空格的字符串。
·（简单点说，next我只要字，nextLine我啥都要）
·首先，next（）一定要读取到有效字符后才可以结束输入，对输入有效字符之前遇到的空格键、Tab键或Enter键等结束符，next（）方法会自动将其去掉，
          只有在输入有效字符之后，next（）方法才将其后输入的空格键、Tab键或Enter键等视为分隔符或结束符。简单地说，next（）查找并返回来自此扫描器的下一个完整标记。完整标记的前后是与分隔模式匹配的输入信息，所以next方法不能得到带空格的字符串


4.异常的类型
Object--Throwable
 `·Exception
·ClassNotFoundException    企图使用一个不存在的类
·IOException        无效输入
·RunTimeException   运行异常
·ArithmeticException     一整数除0
·NullPointException通过一个null引用变量访问的一个对象
·IndexOutOfBoundsException   数组超过下标
·IllegalArgumentException     传递给方法的参数不合法或不合适
·……
·……
·Error    系统错误
·LinkageError
·VirtualMachineError  java虚拟机中断或者没有继续执行的资源
·……


   ·RunTimeException和Error是一个免检的异常，其他异常是必检异常，免检异常发生是逻辑错误，不对免检异常写异常处理。
比如写程序的时候出现红色下划线可以改的是必检异常。


5.如果和声明抛出和捕获一个异常
声明异常：
·方法要抛出的异常必须在方法头中显示的声明，这样方法的调用者会被告知该方法存在何种异常在主函数中会有处理。
·每个方法都必须声明抛出的必检异常。
       ·public void myMethod() throws IOException,……，
·如果方法没有在父类中声明异常，那么就不能在子类中对其进行覆盖声明异常
抛出异常：
·IllegalArgumentException ex = new IllegalArgumentException（“wrong argument”）；throws ex；
等价于 throw new IllegalArgumentException（“wrong argument”）；


捕获异常：
·catch块的异常被指定的顺序是非常重要的，如果父类的catch块出现在子类的catch之前，编译会出错。
 因为如果父在前，会被父的catch捕捉走，不能进行相应的编译
·如果执行完try没有出现错误是会跳过所有的catch语句的，
·如果出现异常，那么先找自己的函数中有没有可以比配的catch，一般没有，一般在他调用者那里
 如果自身没有，就去查第一层调用者必须method2中是否有匹配的catch，如果有就使用，但是会退出method3函数，就相当于把执行的权利返回给了method2函数。
 如果method2中也没有，那么把执行能力给method1中， 有执行，没有在返回在找。直到返回到自顶层还是没有catch，那么就报错信息。打印该信息。


6.一个具体实例


·异常处理器使用System。out。print（ex）答应一个有关异常的短信息ex。toString（）。
·输出是java.lang.IOLeagalArgumentException：radius cannot be negative
number of objects created:1


public class array {
public static void main(String[] args)
{
try
{
Circle c1 = new Circle(5);
Circle c2 = new Circle(5);
}
catch(IOLeagalArgumentException ex)
{
System.out.println(ex);
}

System.out.println("number of objects created" + Circle.getNumber());
}

}
class Circle
{
private double radius;
private static int number = 0 ;

public Circle()
{
this(1.0);
}

public Circle(double newRadius)
{
setRadius(newRadius);
number++;
}
public double getRadius()
{
return radius;
}
public void setRadius(double newRadius) throws IOLeagalArgumentException
{
if(newRadius >= 0)
radius = newRadius;
else
throw new IOLeagalArgumentException("radius cannot be negative");
}
public static int getNumber()
{
return number;
}
public double findArea()
{
return radius * radius * Math.PI;
}
}


7.finally的使用
try{ statements }；
catch（TheException ex）{ handling ex}；
finally{finalStatements}；

·如果try没有异常那么执行finally后，执行try块后的语句；
·如果try出现错误，那么停止try中其他程序的执行，执行catch语句，然后执行finally语句后执行try之后的语句
·如果try的异常没有被任何的catch捕获，就会跳过try语句的其他语句，执行fianlly语句，并将异常传递给调用者。
   finally的作用就是无论try出不出错，finally都会执行其中的代码。


8.使用情况
·由于异常处理需要在方法链中来回调用与查找，因此会浪费很多资源。
·通常，一个项目中多个类都会发生共同的异常应该考虑作为一个异常类，对于发生的个别的方法的简单错误应该进行局部处理。




--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------


字符串处理
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1.常用的函数。
· ==  与equals
==只能判断是否是指向同一个对象，但是equal可以判断是否内容相同，调用是s1.equals（s2）
·compareTo（）
用来比较大小，如果s1.compareTo（s2），如果s1小于s2，那么返回一个负数，如果大于返回一个整数，如果相等返回0.
不可以使用> < 比较大小，因为是字符串比较。同时compareTo（）是比较两个字符串第一个位，然后是第二位，直到比较结束。
2.String类中的函数
·返回字符串的字符个数 length（）
·返回这个字符串的指定下标处的字符 charAt（index：int）：char
·返回连接这个字符串和字符串s1所构成的新字符串 concat（s1：string）：String
虽然+也可以实现连接的功能，但是+连接的两个变量必须有一个是String类型，否则不可以变成字符串的连接。
·换取子串
返回这个字符串以指定beginIndex开始延续到这个字符串结尾 substring（beginIndex：int）：String 
返回这个字符串以指定beginIndex开始延续到endIndex-1的字符串
·将字符串都转换为小写字符 toLowerCase（）：String
·都转为大写字符  toUpperCase（）：String
·用newChar替换oldChar字符  replace（oldChar，newChar）：String


3.字符串转换成数组
·字符串转成数组：toCharArray（） ， char[] chars = "java".toCharArray();
·getChars(int srcBegin , int srcEnd , char[]dst ,int destBegin)
eg: char[] dst = {'a','b'……}；
   “SJIEJF22”.getChars（）；


4.Character类 -- 对单个字符进行处理，经常用到
常用函数：Character（）：创建一个字符对象
 equals（anotherCharacter：Character）：int
·判断
         isDigit（ch：char）：boolean 
 isLetter（ch：char）：boolean
 isLetterOrDigit（ch：char） ：boolean
 isLowerCase(ch：char） ：boolean
 isUpperCase（ch：char） ：boolean
·转换
 toLowerCase（ch：char）：char
 toUpperCase（ch：char）：char


5.StringBuilder和StringBuffer类
功能比String强大，可以对定义的字符串进行修改；
使用：
函数：append（data：char[]）：StringBuilder //在生成器后追加该data的数据，char【】，String，都可以
     reverse（）：StringBuilder //倒置该字符串
     replace（startIndex，exdIndex，string s）：StringBuilder startIndex都是角标的意思，s的从0开始。endIndex要减1；
4.例题：
·找相同字母出现的次数
import java.util.*;
public class array {
public static void main(String[] args)
{
Scanner input = new Scanner(System.in);

System.out.println("enter a string:");
String s = input.nextLine();

int[] count = countLetters(s.toLowerCase());//其实两个数组的大小是一样的，但是此处只声明了一个count数组，但是调用了函数，因为该函数会返回一个数组，在取count的长度即可使用

for(int i = 0 ; i<count.length;i++)
{
if(count[i] != 0)
System.out.println((char)('a' + i) + "appears" + count[i] + ((count[i] == 1) ? "time" : "times"));
}
}

public static int[] countLetters(String s)
{
int[] counts = new int[26];//此处定义一个count，

for(int i = 0 ; i < s.length() ; i++)
{
if(Character.isLetter(s.charAt(i)))//.nextLine接受的是字符串，用charAt提取每个字符
{
counts[s.charAt(i) - 'a']++;
}
}
return counts;
}

}


·判断回文串


import java.util.*;
public class array {
public static void main(String[] args)
{
Scanner input = new Scanner(System.in);

System.out.println("enter a string");
String s = input.nextLine();

System.out.println("ignoring the characters" + s + "a palindrome?" + isPalindrome(s));
}
public static boolean isPalindrome(String s)
{
String s1 = filter(s);//对s中不是数字或者字母的字符进行处理
String s2 = reverse(s1); //对s1翻转显示
return s1.equals(s2); //如果翻转后的字符串和处理后的是一样的，证明是回文
}
public static String filter(String s)
{
StringBuilder stringBuilder = new StringBuilder();
//create a string builder 存储符合规定的char

for(int i = 0 ; i < s.length() ; i++)
{
if(Character.isLetterOrDigit(s.charAt(i)))//判断单个字符是不是数字或者字母
{
stringBuilder.append(s.charAt(i));
}
}
return stringBuilder.toString();
}

public static String reverse(String s)
{
StringBuilder stringBuilder = new StringBuilder(s);
       stringBuilder.reverse();//invoke reverse in StringBuilder
return stringBuilder.toString();//如果使用了StringBuilder类，那么必须使用toString来显示。
//return stringBuilder.reverse();如果直接返回这条语句，必须更改函数中返回的类型，由String到StringBuilder。
}


}



--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
抽象类和接口


--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
1.抽象类
一个设计的得很抽象的父类，没有具体的实例可以作为一个抽象类，其中有抽象方法。（他们的实现取决于几何对象的具体类型，在父类中只是属于声明，具体定义在自己的类中）
如果一个类中具有抽象的方法，那么该类也必须被声明为抽象类，加abstract。
抽象类不可以用new创建实例
抽象方法只有定义没有实现，它的实现由子类提供，
抽象类的构造方法用protected，因为还有子类使用，而一般的构造方法用public，
创建一个具体的子类的实例时，他的父类的构造方法被调用以初始化父类中的定义的数据域
及时他的父类是具体的，但是子类可以是抽象的。
抽象类中可以不包括抽象的函数
抽象类可以作为一种数据类型。GeometricObject[] objects = new GeometricObject[10];


2.接口




































·默认值
int[] a 声明，没有初始化，默认为null；

int[] a = new a[5]; 初始化为默认是0；


·局部变量的初始化
局部变量声明后，java虚拟机是不会自动的为它初始化一个默认值，因此局部变量必须经过显示的初始化才能使用，否则会报错。





--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
文件的输入和输出


--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
·PrintWriter写数据
public static void main(String[] args) throws Exception
{
java.io.File file = new java.io.File("scores.txt");
   if(file.exists())
   {
    System.out.println("file already exists");
    System.exit(0);
   }
   java.io.PrintWriter output = new java.io.PrintWriter(file);
   
   output.print("jaon T smith");
   output.print(90);
   output.print("sdkjfalj K joej");
   output.println(85);
   
   output.close();
}


·在路径中会找到这个文件。
·一定会有close文件关闭。


·Scanner读数据
·要先给该对象一个file。
·记得关闭该文件
public static void main(String[] args) throws Exception
{
//creat a File instance
java.io.File file = new java.io.File("scores.txt");

//creat a Scanner for the file
Scanner input = new Scanner(file);

while(input.hasNext())  //如果这个扫描器还有可读的数据
{
String firstName = input.next();
//String mi = input.next();
//String lastname = input.next();
//int score = input.nextInt();

System.out.println(firstName );
//System.out.println(mi );
//System.out.println(lastname );
//System.out.println(score );

}
   input.close();


---------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------
对象数组的创建
class Aninals
{
   float v;
   int f；
}
class students
{
float s;
int w；
}
class main
{
public static void main（String【】 args）
{
Aninals[] aninal = new Aninals【4】；//声明了一个长度是4的可以放Aninals类的数组
System.out.print（aninal【0】）；//空指针，输出null
for（int i= 0；i<4；i++）
{
//aninal【i】 = new students（）；//不可以，因为必须实例化Aninals；
aninal【i】 = new Aninals（）； //必须给对象数组实例化，才可以使用，否则会报错
aninal【i】.v = i；
}


}
}
·变形：如果students类继承 Aninals类，那么//aninal【i】 = new students（）就可以写。也可以成立。


------------------------------------------------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------------------------------------------
sort函数：
·默认是升序排列；
import java.util.Arrays;


public class pratice123 {
public static void main(String[] args)
{
int[] arr = {1,4,6,333,8,2};
Arrays.sort(arr);
for(int i = 0; i<arr.length;i++)
{
System.out.print(arr[i] + " ");
}
}
}
输出：1 2 4 6 8 333 
·如果要降序排列，需要重写该程序
public class pratice123 {
public static void main(String[] args)
{
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(1);
list.add(55);
list.add(9);
list.add(0);
list.add(2);
Collections.sort(list, new Comparator<Integer>() {
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });//使用Collections的sort方法，并且重写compare方法
        for(int a :list){
            System.out.println(a);
        }
}
}




·输出数组的两种形式：
  for(int b:a)  // for循环简写JDK1.5或更高版本 b就相当临时变量 int b = a[i];
  {
       System.out.println(b);
  }
  
  // 等效形式
  for(int i = 0;i < a.length;i++)
  {
   int b = a[i];
   
   System.out.println(b);
  }




------------------------------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------------------------------------
·二维数组赋值


public class Test{
    
   public static void main(String[] args){
 
           //第一种：定义的时候不规定行和列。直接赋值数据
           //int[][] arr1 = new int[][]{{1,2}, {2, 3}, {4, 5}};
           int[][] arr1 = {{1,2}, {2, 3}, {4, 5}};
       System.out.println("arr1的数值：");
       for(int i=0; i<3; ++i)
          for(int j=0; j<2; ++j)
             System.out.println(arr1[i][j]);
            
           //第二种  先定义行列的个数，在赋值每个数字
       int[][] arr2 = new int[4][3];
       System.out.println("arr2的数值：");
       for(int i=0; i < arr2.length; ++i)
          for(int j=0; j<arr2[i].length; ++j)
             arr2[i][j] = i*j;
       for(int i=0; i<arr2.length; ++i)
          for(int j=0; j<arr2[i].length; ++j)
             System.out.println(arr2[i][j]);
       System.out.println("arr3的数值：");
        
           //第三种：这种赋值方式比较牛逼啊！第二维的长度可以在随后的代码中执行
//先规定一共有多少行，在分别对每一行赋不一样的长度。每行进行处理。
           int[][] arr3 = new int[5][];
       for(int i=0; i<arr3.length; ++i){
           arr3[i]=new int[i+1];
           for(int j=0; j<arr3[i].length; ++j)
              arr3[i][j]= i+j;
       }
       for(int i=0; i<arr3.length; ++i)
          for(int j=0; j<arr3[i].length; ++j)
             System.out.println(arr3[i][j]);
 
   }
}
·怎么快速赋值给二维数组全0？
在人间