java 基础知识 3

Scanner

用scanner实现字符窗口输入

Scanner sc=new Scanner(System.in);String day1=sc.next();

.next()和nextLine()

Next()一定要读取到有效字符后才可以结束输入，对于有效字符之前遇到的空格键。Tab键或enter键等结束符，next()方法会自动将其去掉，只有在输入有效字符后，才能输入以上各键，即next()得不到带空格的字符串。NextLine()返回Enter键之前所有字符

Next(),nextLine()先后顺序

Scanner sc=new Scanner(System.in);System.out.println("请输入日期");String day1=sc.next();System.out.println(day1);System.out.println("请输入日期2");String day2=sc.nextLine();System.out.println(day2);

Next()遇到第一个字符（非空格换行符）时开始扫描，当遇到第一个（空格或换行符时）结束扫描。然后使用nextLine（）。读取的第一个字符是换行符（或空格，上例为空格）

While / do while

While先判断后循环。Do whle 先执行一次在判断，后决定是否循环

如果循环内条件相同，如果条件成立，两者循环次数相同。如果不成立，do while 会执行一次，while进入循环

面向对象三个特点

封装，继承，多态

类与类之间关系：常用三种

依赖（“user-a”关系）

聚合（“has-a”关系）

继承（“is-a”关系）

构造器          

         Java提供默认的构造器

         可被重载

名称与类名相同

无返回值

利用new 关键字调用

默认初始化和显式初始化

只是声明了属性，并且在构造器没有对这些属性赋值，那么程序会给这些属性进行默认初始化

显示初始化是在声明属性是或在构造器内对属性赋值

private  String  name  = “Odie”; 

或者

private  String  name; public  Dog() { name  =  “Odie”; }

默认构造器

默认构造器是指没有参数的构造器，比如 Dog 类的默认构造器就是

public  Dog() {    //代码 } 

每个类都至少有一个构造器。如果不编写构造器，Java 将提供一个默认构造器，此时这个构造器的内容为空。您可以直接使用 new  Xyz();来创建一个对象实例。如果一个类里已经提供了至少一个带参构造器，但是没有默认构造器，那么在创建实例的时候没有提供构造参数就被视为非法。

This关键字

this 关键字用于表示当前类对象，一般用于两种情况：

解析实例变量和参数之间的模糊性

将当前对象作为参数传递给另一个方法

public  Dog(String  name, int  age)   {     this.name  =  name;    this.age  =  age;   }  

this 关键字还能将当前对象作为参数传递给另一个方法：

public  Dog2  addAge(int year)   {     Dog2  newDog  = new  Dog2(this);  //this引用当前Dog2对象     newDog.age  = newDog.age  +  year;     returnnewDog; }

调用另一个构造器

关键字 this 还可以表示当前类的另一个构造器。如果在一个构造器内写上 this(…)，

这个构造器就调用了同一个类的另一个构造器。如：

  public  Dog()   {     //调用了带参的构造器     this(null,  0);   } 

注：要放在第一行

当调用 new  Dog()时，Dog()构造器会去调用 Dog(String,  int)构造器

封装

是一种隐藏类实现的某些元素，但为其他类提供公共接口的方法通过私有化来隐藏属性，然后提供获取访问方法 getXxx() （Get 访问器， getters）

和存储方法 setXxx()（Set 访问器，setters）。

包（package）

可以把类组织起来，方便地进行管理代码。使用包还可以保证类名的唯一性。例如两个程序员都创建了 Dog 类，如果放在不同的包中就不会产生冲突。包在磁盘

上以文件夹的形式存在。

import 语句可以导入一个特定的类或者整个包。

如果想要导入一个包例如 java.util 包下所有类可以使用

import  java.util.*;

需要注意的是：入这种导入方式不会导入 java.util  包的子包下的类。另外，只能用*导入一个包而不能使用 import  java.*.* 导入以 java  为前缀的所有的包有可能多个包中有相同类名的类，例如 java.util 包和 java.sql 包下都有 Date 类，

即使您全部导入这两个包

import  java.util.*; import  java.sql.*; 

在程序使用 Date 类时还是会遭遇编译错误（The  type  Date  is  ambiguous） ：

  Date  myDate;  //Date 类型声明不清晰，不知道是哪个包下的 Date。 

如果这两个 Date 都需要使用，那么解决方案必须是加上完整的包名。

DogTest.java 分别放到com.mybook.entity 和com.mybook.test 下，想要编译这两个源程序，要基于目录编译

javac  com/mybook/test/DogTest.java javacom.mybook.entity.DogTest 

我们知道包在磁盘上是以文件夹的形式存在，所以编译的时候使用文件夹分隔符“/”，然而运行的时候要带上包名，使用包分隔符“.”

字符串的拼接

在 Java 中可以使用“+”号把两个字符串拼接成一个新的字符串，例如

String  hello  = "Hello"; String  person  =  "程序员"; System.out.println(hello+person); 

将会输出“Hello  程序员”

比较字符串

s1.equals(s2);

 

如果想要检测两个字符串值相等而且忽略大小写可以使用 equalsIgnoreCase 方法:

    “HELLO WORLD”.equalsIgnoreCase(“hello  world”);//返回 true 

但是使用“==”判断两个字符串就不一定是那么回事了

String  s1  =  “Hello”; String  s2  =  “Hello”; String  s3  =  new  String(“Hello”);System.out.println(s1==s2);  //返回 true System.out.println(s1==s3);  //返回 false 

s1,  s2,  s3 虽然值都是“Hello”，但是并不一定指向同一个对象，s1==s2 返回 true

是因为 JVM 将相同的字符串共享了，s1==s3 返回 false 是因为 s1 和 s3 在内存中并不是同一个地址（不是同一个对象，s3 使用了 new 关键字强制在内存中新建了一个对象）。除非 JVM 始终将相同的字符串共享，否则不能使用“==”进行检测。实际上，使用拼接、subString 提取子串等操作产生的字符串不是共享的，所以千万 不要使用“==”来判断字符串是否相等。

  字符串 API

返回值

方法

char

charAt(int  index) 返回指定索引处的  char  值

int

compareTo(String anotherString)  按字典顺序比较两个字符串。

int

compareToIgnoreCase(String str)  按字典顺序比较两个字符串，不考虑大小写。

boolean

contains(CharSequence s) 当且仅当此字符串包含指定的 char值序列时，返回  true

static

String

copyValueOf(char[]  data)  返回指定数组中表示该字符序列的  String。

static

String

copyValueOf(char[]  data,  int offset,  int  count返回指定数组中表示该字符序列的  String。

boolean

endsWith(String suffix)  测试此字符串是否以指定的后缀结束。

boolean

equals(Object anObject)  将此字符串与指定的对象比较

boolean

equalsIgnoreCase(String anotherString)  将此  String  与另一个  String  比较，不考虑大小写。

static

String

format(Locale  l,  String format,  Object...  args)  

使用指定的语言环境、格式字符串和参数返回一个格式化字符串。

static

String

format(String  format,  Object... args)  

使用指定的格式字符串和参数返回一个格式化字符串。

int

indexOf(int  ch)  返回指定字符在此字符串中第一次出现处的索引。

int

indexOf(int  ch,  int fromIndex)  返回在此字符串中第一次出现指定字符处的索引，从指定的索引开始搜索。

int

idexOf(String  str) 返回指定子字符串在此字符串中第一次出现处的索引。

int

indexOf(String  str, int  fromIndex)  返回指定子字符串在此字符串中第一次出现处的索引，从指定的索引开始。

boolean

isEmpty()当且仅当 length()为  0  时返回  true。

int

lastIndexOf(int  ch)  返回指定字符在此字符串中最后一次出现处的索引。

int

lastIndexOf(int  ch, int  fromIndex)  返回指定字符在此字符串中最后一次出现处的索引，从指定的索引处开始进行反向搜索。

int

  lastIndexOf(String  str) 返回指定子字符串在此字符串中最右边出现处的索引。

int

lastIndexOf(String  str, int  fromIndex)  返回指定子字符串在此字符串中最后一次出现处的索引，从指定的索引开始反向搜索。

int

length()  返回此字符串的长度。

boolean

matches(String  regex) 告知此字符串是否匹配给定的正则表达式。

String

replace(char  oldChar, char  newChar)  返回一个新的字符串，它是通过用  newChar  替换此字符串中出现的所有oldChar  得到的。

String[]

split(String  regex) 根据给定正则表达式的匹配拆分此字符串。

boolean

startsWith(String prefix)  测试此字符串是否以指定的前缀开始。

String

substring(int beginIndex)  返回一个新的字符串，它是此字符串的一个子字符串。

String

substring(int beginIndex,  int  endIndex)  返回一个新字符串，它是此字符串的一个子字符串。

char[]

toCharArray()  将此字符串转换为一个新的字符数组。

String

toLowerCase()  使用默认语言环境的规则将此  String  中的所有字符都转换为小写。

String

toString()  返回此对象本身（它已经是一个字符串！）

String

toUpperCase()使用默认语言环境的规则将此  String  中的所有字符都转换为大写。

String

trim()返回字符串的副本，忽略前导空白和尾部空白。

大数值

基本数据类型中的整数和浮点类型精度不能够满足需求，可以使用 java.math 包中两个类 BigInteger 和 BigDecimal。这两个类可以处理包含任意长度数字序列的数值，在编写天文、金融方面等应用程序十分有用

您可以使用 valueOf 方法将任意普通数值转换成大数值

BigDecimal  d  = BigDecimal.valueOf(888); 

但是您不能使用普通的运算符（+,-­‐,*,/）处理大数值，只能使用大数值类中提供的方法

 add();subtract  ();  multiply();  divide();等。

例如：

BigDecimal  d1  = BigDecimal.valueOf(2.0); BigDecimal  d2  = BigDecimal.valueOf(1.1); System.out.println(d1.subtract(d2)); 

此时，将会输出 0.9 而不是以前 double 类型的 0.8999999999999999，避免了精度损失。

Math

Math.PI   圆周率 π

Math.E  自然对数 e

Math.pow(x,  y)  //表示 x 的 y 次方

Math.sin

Math.cos

Math.tan

Math.exp  E的幂

Math.log

  复制数组

Java 在 System 类中提供了arraycopy()方法用于复制数组。这个方法有 5 个参数

System.arraycopy(src,  srcPos, dest,  destPos,  length)

src  -­‐  源数组。

srcPos  -­‐  源数组中的起始位置。

dest  -­‐  目标数组。

destPos  -­‐  目标数据中的起始位置。

length  -­‐  要复制的数组元素的数量。

public  class  ArrayCopyTest{  public  static  void main(String[]  args)  {    //   原来的数组    int[]  originArray =  {  1,  2,  3,  4,  5  };    //   一个新的数组    int[]  newArray1  = newint[10];    //   把原数组的内容复制到新数组    System.arraycopy(originArray, 0,  newArray1,  0,originArray.length);    for  (int  element :  newArray1)    {      //   输出新数组的每个元素      //   结果是1  2 3  4  5  0  0  0  0  0     System.out.print(element  +  "  ");    }}

如果新数组内各个元素都有值，那么源数组复制过来的时候会覆盖掉部分值：

int[]  newArray2  =  { 10,  9,  8,  7,  6,  5,  4,  3, 2,  1  }; 

  //把原数组的内容复制到第二个新数组，新数组的部分内容会被覆盖掉

  System.arraycopy(originArray, 0,  newArray2,  0,  originArray.length);   for  (int  element  : newArray2)   {     //  输出新数组的每个元素     //  结果是1  2 3  4  5  5  4  3  2  1  部分内容被覆盖掉了     System.out.print(element +  "  "); }

数组排序

Arrays 类的 sort 方法

引用数据类型的数组进行排序，就需要访问到类的属性，然后再对属性值进行排序

例如对某个公司的员工进行排序，首先按照工资排序，不排除工资相同的员工出现。如果工资相同了，那么作为 HR 可能会考虑按照姓名的英文排列。

因为是引用数据类型，所以我们先定义类 Employee

package  com.mybook.arraytest.ref;public  class  Employee{  private  String  name;  privatedouble  salary;  public  Employee(String name,  double  salary)  {    this.name  =  name;this.salary =  salary;}  //省略getters和setterspublicStringtoString()  {   return" 姓名："  +  this.getName()  +  " ，工资" +  this.getSalary();  }}

排序就需要访问到 Employee 的属性，再按照要求进行排序。此时需要自定义一个比较器，也就是自定义一个实现Comparator 接口的类这个类实现一个 compare 方法， 比较用来排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回-­‐1、0 或 1

package com.mybook.arraytest.ref;import java.util.Comparator;public class  MyCompare  implements  Comparator<Employee>//尖括号内是泛型，表示这个比较器只比较Employee 类型的数据{  @Override  public int  compare(Employee  e1,  Employee  e2)  {   if(e1.getSalary()  >  e2.getSalary())    {     return  1;  //    }   else  if(e1.getSalary()  <  e2.getSalary())    {     return  -­‐1;    }   else    {     return  e1.getName().compareTo(e2.getName());    }  }}

最后使用 Arrays.sort 方法进行排序，此时排序需要把比较方式传递给 sort 方法。

package com.mybook.arraytest.ref;import java.util.Arrays;public class  RefSortTest{  public static  void  main(String[]  args)  {        //需要排序的员工数组   Employee[]  emps  =  {  new  Employee("Tom", 6000),       new  Employee("Jerry",  7000),  new Employee("Aaron",  9000),       new  Employee("Jim",  6000),  new Employee("Bart",  10000)  };   Arrays.sort(emps,  newMyCompare());  // 排序，传入比较器   for  (Employee  e  :  emps)    {     System.out.println(e);    }  }}

二维数组

二维数组的声明必须要指定第一维的长度

int[][] twoDim  =  new  int[4][];

是合法的，然后可以分别处理第一维的每个元素

twoDim[0] =  new  int[2]; 

twoDim[1] =  new  int[4]; 

twoDim[2] =  new  int[6]; 

twoDim[3] =  new  int[8]; 

此时就成了一个不规则数组，每一行的列数不同

您不可以这样声明二维数组

int[][]  a =  new  int[][5];

这样的写法表示第一维度没有确定，第一维度没有确定的情况下是无法确定第二维度的。

面向对象技术一般分为 3 个部分：

面向对象分析(Object-OrientedAnalysis，简称 OOA)

该步骤按照面向对象的思考方式提取项目的需求信息， 一般由系统分析员负责， 本部分形成文档为《项目需求分析说明书》 。

 面向对象设计(Object-OrientedDesign，简称 OOD)

该步骤按照《项目需求分析说明书》进行模块划分，以及进行模块的概要设计，一般由高级程序员负责，本部分形成文档为《项目概要设计说明书》 。

面向对象编程(Object-OrientedProgramm，简称 OOP)

该步骤按照《项目概要设计说明书》细化每个模块的结构，一般由程序员负责，本部分形成文档为《项目详细设计说明书》 。最后由编码员(Coder)按照《项目详细设计说明书》进行具体的编码。这个就是面向对象开发的标准过程的简单描述。

类

 

类(class)是 Java 语言的最小编程单位，也是设计和实现 Java 程序的基础，

构造方法(Constructor)，也称作构造函数、构建器

构造方法的功能：实现类这种数据类型的变量的初始化。由于类是一种复合数据类型，而复合数据类型的变量也比较复杂，所以专门需要对该类变量进行初始化，则语法上提供了专门的结构——构造方法。 这就是构造方法出现的原因。 而方法实现的是逻辑的功能，

对应于逻辑上的算法，更多的是实现程序逻辑。所以构造方法是语法结构，而方法是逻辑功能，两者之间根本无关。

对象的存储形式

对象是一个复合数据类型的变量， 其存储方式和一般变量的存储方式也不相同。 在Java 的执行环境中，存储区域一般分为两类：

 栈内存

该区域存储基本数据类型

 堆内存

存储实际的对象内容。

而实际的对象存储比一般变量复杂，对象的存储分为两部分：对象的内容、对象内容的起始地址

在使用面向对象技术设计项目时，一般的步骤如下：

1、 抽象类

2、 抽象类的属性和方法

3、 通过对象的关联构造系统

 抽象类

抽象类最基本的方式是——将名词转换为类。

 抽象类的属性和方法

把系统中的类抽象出来了以后，就可以设计每个类的内部结构了，而每个类内部最重要的结构就是属性和方法了。

抽象属性最基本的方式是——将数据抽象为属性。

抽象方法最基本的方式是——将功能抽象为方法。