Java知识点总结_java知识体系

Java发展历程与语言特点：

跨平台、适合于分布式计算环境的纯面向对象语言，Java是一种编程语言, 又是一种平台和规范

语言特点：（JAVA是一种“简单、面向对象、分布式、解释型、健壮、安全、体系结构中立、可移植、高性能和动态”的编程语言）

1）简单（完全面向对象的，它是最容易学习的面向对象的编程语言之一，同时它还提供了大量可重用的类库，Java的简单性是以增加系统的复杂性为代价的）

2）面向对象（支持封装、继承、多态）

3）分布式（数据分布支持（通过Java的URL类可以访问网上的各类信息资源，访问方式完全类似于本地文件系统）、操作分布支持（通过在web页面中的小应用程序(Applet)等将计算从服务器分布至客户机，避免网络拥挤，提高系统效率））

4）半编译、半解释（Java源程序经编译器编译后产生字节码（bytecode），Java解释器解释执行字节码，优点:     兼具编译执行的效率优势和解释执行的灵活性；  提高了应用程序的可移植性：源程序、中间代码）

5）平台无关性/可移植性（程序不经过修改而在不同的硬件或软件平台上运行的特性，Java可移植性源于两方面：   Java的半编译、半解释的特征；   Java采用标准的独立于硬件平台的数据类型）

6）安全性（Java的内存分配和引用模型对于程序员透明，完全由底层的运行系统控制。在语言和运行环境中引入了多级安全措施：内存布局与C、 C++不同，不是由编译器决定，而是运行系统根据所在的硬件平台的特性决定； 取消了C、C++的指针，JAVA编译器通过符号指针来引用内存，由JAVA运行系统在运行时将符号指针具体解释为实际的内存地址。字节码验证：运行系统引入字节码验证器，其中包含简单的规则验证程序，以确保遵循规则）

7）多线程

8）健壮（Java致力于检查程序在编译和运行时的错误。 运行错误的处理机制 内存的垃圾收集机制 不使用指针操作）

不同操作系统环境的设置与编译运行命令：

开发与运行Java程序需要经过的三个主要步骤为：编辑源程序、编译生成字节码、解释运行字节码

• It translates a Java program into byte-code.（Byte-code is the machine language for a hypothetical computer (or interpreter) called the Java Virtual Machine, a byte-code program is easy to translate into machine language for any particular computer.）

• A program called an interpreter translates each byte-code instruction, executing the resulting machine-language instructions on the particular computer before translating the next byte-code instruction.

• Most Java programs today are executed using a Just-In-Time or JIT compiler in which byte-code is compiled as needed and stored for later reuse without needing to be re-compiled.

• Use the compiler to translate the Java program into bytecode (done using the javac command)

· the byte-code can be used on any computer with a byte-code interpreter and without a need to recompile, so it can be sent over the Internet and use anywhere in the world. So this makes Java suitable for Internet applications.

运行环境的种类： JAVA Application （JAVA解释器）、 JAVA Applet（JAVA兼容的Web浏览器）

JDK工具：

appletviewer： Applets是被嵌入在网页里的Java程序，可以用Web浏览器运行appletsappletviewer 可运行applets而不必运行 Web浏览器。 用法： appletviewer < .HTML文件的URL>

javap反汇编程序： javap反汇编程序可以从字节码文件恢复 java 源代码。 用法：        javap <.class文件列表> 文件名由空格分隔

典型Java程序：字符与图形界面简介

• JavaFX is a set of packages that allow Java programmers to create graphics and media applications

JavaFX是最新的图形化工具包，程序员可以创建富图形化和富媒体应用程序

基本元素：关键字 表达式 标识符 运算符 分支和循环控制

在Java的基本数据类型中，char型采用Unicode编码方案，每个Unicode码占用 2 字节内存空间。

不是关键字：sizeof，字面常量：true、false、null

标识符：

 

 

 若想对比两个对象的实际内容是否相同,使用方法equals(),但不适用于自己创建的类！

 

若为String，则使用s1.compareTo(s2) 

 

 

 

八种基本数据类型的定义与使用

Float类型的数据其最后一个字符之后需加入“F”或“f”，如果数据其最后一个字符之后没有“F”或“f”，则默认为double类型的数值。

reference 类型：数组Array ，类 classe，接口interface。reference 类型的变量可简单认为是所引用对象的内存地址。

String类

 String不是基本数据！

创建字符串变量：

S=new String(“abc”);
S=“abc”;
String tomName=String(“tom”);
String(char a[]);//通过数组创建字符串对象
String(char a[],int startIndex,int count);//截取数组元素的一部分来创建字符串对象

s1.length();//获取字符串的长度
charAt(int index);//获得字符串指定位置的字符
//比较
String s1=“abc”,s2=“abc”,s3=“Abc”;
s1.equals(s2);   //true
s1.equals(s3); //false
s1==s2; //false,引用
//equalsIgnoreCase(String s)，比较时忽略大小写
String s1=“abc”,s2=“Abc” ；
s1. equalsIgnoreCase(s2); //true
//public boolean startsWith(String s)：判断当前字符串的前缀是否含有字符串s
String s1=“220123456”,s2=”210654321”;
s1. startsWith(“220”); //true
s2. startsWith(“220”); //false
//public boolean endsWith(String s)：判断当前字符串的后缀是否含有字符串s
s1. endsWith(“456”); //true
//public int compareTo(String s)：按字典顺序比较当前字符串和s
//public int compareToIgnoreCase(String s):比较时忽略大小写
s1.compareTo(s2);
//public int indexOf(String s)返回第一次找到时的下标,如果没有找到，则返回-1
//public int indexOf(String s, int strartPoint)从指定的下标开始找子串，返回第一次找到时的下标,找不到则返回-1
String s=“I am a good student”;
S.indexOf(“a”);      //=2
S.indexOf(“a”,3);  //=5
S.indexOf(“k”,2);   //=-1
//字符串的截取（求子串）
"unhappy".substring(2);// returns "happy" 
"Harbison".substring(3);// returns "bison“
"emptiness".substring(9);// returns "" (an empty string)
"hamburger".substring(4, 8);// returns "urge" 
"smiles".substring(1, 5);// returns "mile" 
//拼接两个字符串，并返回一个新字符串,源字符串不会被修改
String s1 = "ABC";
String s2 = "XYZ";
s1 = s1.concat(s2);  // s1 = s1 + s2;
//替换public String replace(char oldChar, char newChar)
String s1 = "mesquite in your cellar";
s1.replace('e', 'o');// returns "mosquito in your collar" 
//public String replaceAll(String regex, String replacement)
String s1 = "opq@#$";
s1.replaceAll(“[a-z]”,”123”);// returns “123123123@#$”
//返回前后没有空格的字符串public String trim()
"Java ".trim();//"Java"
//字符串与相应数值的相互转化public static int parseInt(String s)
int i=Integer.parseInt(“123”);
public static float Float.parseFloat(String s) 
public static double Double.parseDouble(String s)
//通过String类的静态(static)成员方法valueOf(…)转为String类型
public String valueOf(byte n)
public String valueOf(int n)
public String valueOf(long n)
public String valueOf(float n)
public String valueOf(double n)
String str=String.valueOf(12313.9876);
Float x=123.987f;
String s=String.valueOf(x);
//对象还可以通过方法toString转化成字符串
Date date=new Date();
System.out.println(date.toString());//Sat Oct 04 21:10:48 CST 2007

求String类对象长度：s.length()//这里有（）！！

在android系统下，默认是UTF8编码，一个中文字符通常相当于3个字节，而gb2312下一个中文相当于2字节。把JVM内存中unicode形式的String按encoding指定的编码，转成字节流。这种情况下可采取以下办法：

byte[] byBuffer = new byte[200];
String strInput="我是字符串";
byBuffer= strInput.getBytes("gb2312");

JVM内部的String，Char都是用unicode存储(没有任何特殊编码) 

buf1 = new StringBuffer();//创建空的StringBuffer对象容量为16字符
buf2 = new StringBuffer( capacity );//创建空的StringBuffer对象指定容量大小
buf3 = new StringBuffer( myString );//创建含有相应字符序列的StringBuffer对象容量为myString.length() + 16
//实例
StringBuffer b = new StringBuffer("hello");

屏幕输出与键盘输出

import java.util.Scanner;
//Scanner Scanner_Object_Name = new Scanner(System.in);
Scanner Keyboard = new Scanner(System.in);
 
int n1 = keyboard.nextInt();//读入int
String s1 = keyboard.next();//读入String
String sentence = keyboard.nextLine();//读入一行

类和方法的定义，成员的封装与隐藏，对象与引用

基本概念：事物的属性或特性可以用变量来表示，行为或功能用方法来反应。

类是同种对象的集合与抽象：在面向对象的程序设计中，定义类的概念来表述同种对象的公共属性和特点。 类是一种抽象的数据类型，它是具有一定共性的对象的抽象，而属于类的某一对象则被称为是类的一个实例，是类的一次实例化的结果。

面向对象的程序设计方法就是将客观事物抽象成为“类”，并通过类的“继承”实现软件的可扩充性和可重用性。

 

 

 

 

 

构造器与方法重载

 

声明对象：声明对象的名字和类型，用类名来说明对象的类型。 格式：type name

说明： 声明对象的规则与变量声明规则相同，但对象变量是引用类型； 在java里类和接口都可以作为数据类型来使用； 对象声明通知编译器name将用来引用type类型的变量 对象声明并不创建新的对象。操作符new通过为新对象分配存储空间来实例化类

 

 System.gc( ); // 申请立即回收垃圾

static关键字/类成员与实例成员：在类中声明一个变量或方法时，可指定它为实力成员或类成员。用static修饰的是类成员（类变量oe类方法）

类变量与实例变量的区别：1）运行时系统在首次遇到类变量时就为类变量分配存储空间；而当创建类的实例对象时才为实例变量分配存储空间。2）不管有多少类的实例，类变量只有一份拷贝，即所有实例共享相同的类变量；而每个实例对象都有自己的实例变量。3）实例变量只能通过对象来访问，而类变量既可以通过类名来访问，也可以通过实例对象来访问。

在该类所有实例之间是共享的。在加载该类时，只分配 一次空间，并初始化。可用来在实例之间进行通信或跟踪该类实例的数目。（e.g.用count++来计数）

 类方法与实例方法的区别：1）实例方法既能访问当前对象的实例变量也能访问类变量；类方法只能访问类变量而不能访问实例变量。2）实例方法只能由实例对象来调用而类方法既可以由实例对象调用也可以由类名直接调用。

 

 Java总是会在尝试使用自动类型转换之前使用重载。如果Java可以找到一个能够匹配引元类型的方法定义，就会使用这个定义。Java尝试寻找参数类型与方法调用中的引元精确匹配的方法名定义，直至尝试失败之后才会尝试方法引元的自动类型转换。（先找是否有重载函数再取进行自动类型转换）

 

 

 

 

 

 

 

 default(缺省访问，包范围的)： 如果没有给定修饰符，那就是default或friendly（友元）的（它不是java的关键字）。拥有缺省修饰符的类、变量或方法对同一个包里的所有类来说都是可访问的。

 一维与多维数组的定义与实现

获取数组长度：c.length（注意没有（）），c.length是final变量，不能对它 再次赋值

每个数组元素是对象的引用，还需要继续创建对象才可以使用。

数组的初始化语句创建数组 int[ ] n = { 10, 20, 30, 40, 50 };

·对基本数据类型：

int[] nums; 
nums = new int[3]; 
nums[0] = 1; 
nums[1] = 2; 
nums[2] = 3;

·对非基本数据类型：

MyDate[] dates;
dates = new MyDate[ 3];
dates[ 0] = new MyDate( 22, 7, 1964);
dates[ 1] = new MyDate( 1, 1, 2000);
dates[ 2] = new MyDate( 22, 12, 1964);
MyDate[] dates = {
new MyDate( 22, 7, 1964),
new MyDate( 1, 1, 2000),
new MyDate( 22, 12, 1964) };

当指定数组参数时，只需要给出数组的基类型，但不需要指定数组的长度。

double[] a = new double[10]
double[] b = new double[30]
SampleClass.incrementArrayBy2(a);
SampleClass.incrementArrayBy2(b);

多维数组定义方式：

int [][] intArray；
int[][][] a2；

分配内存空间:

int[][] a = new int[2][3];//直接为每一维分配空间
int twoDim [][] = new int [][ 4];  //error
//分别为每一维分配空间
int[][] a = new int[2][ ];
a[0] = new int[3];
a[1] = new int[3];
//可以为每行设置为空间大小不同的数组
a[0] = new int[3];
a[1] = new int[5];

初始化：

int a[][] = {{2,3}, {1,5}, {3,4}};
double[ ][ ] c =
{ 
    {1.0, 2.0, 3.0, 4.0}, 
    {0.0, 1.0, 0.0, 0.0}, 
    {0.0, 0.0, 1.0, 0.0} 
}; 

数组数据的复制，通过拷贝数组的函数

System.arrayCopy(Object source, int srcIndex, Object dest, int destIndex, int length)
public class ArrayCopyDemo { 
	public static void main(String[] args) { 
		char[] copyFrom = { 'd', 'e', 'c', 'a', 'f', 'f', 'e', 'i', 'n',
					'a', 't', 'e', 'd' };
		char[] copyTo = new char[7]; 
 
		System.arraycopy(copyFrom, 2, copyTo, 0, 7); 				            
        System.out.println(new String(copyTo)); 
	}
} 

继承与多态的Java描述与实现

类java.lang.Object处于类层次树的根部，其他所有的类都直接或间接地为它的子类

 

 

 

 

 

 

 抽象类中不一定要包含abstract方法，但是，一旦某个类中包含了abstract方法，则这个类必须声明为abstract类。

使用多态进行程序设计的核心技术之一是使用上转型对象，即将abstract类声明对象作为其子类的上转型对象，那么这个上转型对象就可以调用子类重写的方法。 所谓面向抽象编程，是指当设计某种重要的类时，不让该类面向具体的类，而是面向抽象类，即所设计类中的重要数据是抽象类声明的对象，而不是具体类声明的对象。

//Geometry.java
public abstract class Geometry { //如果使用接口需用interface来定义Geometry。
     public abstract double getArea();
}
Circle.java
public class Circle extends Geometry {
    double r;
    Circle(double r) {
        this.r=r;
    }
    public double getArea() {
        return(3.14*r*r);
    }
}
 
//Rectangle.java
public class Rectangle extends Geometry {
    double a,b;
    Rectangle(double a,double b) {
        this.a=a; this.b=b; 
    }
    public double getArea() {
        return a*b;
    }
}
 
//Pillar.java
public class Pillar {
    Geometry  bottom;        //bottom是抽象类Geometry声明的变量
    double height;
    Pillar (Geometry bottom,double height) {
        this.bottom=bottom; this.height=height;
    }
    public double getVolume() {
        return bottom.getArea()*height; //bottom可以调用子类重写的getArea方法
    }
}
 
//Application.java
public class Application{
    public static void main(String args[]){
        Pillar pillar;
        Geometry bottom;
        bottom=new Rectangle(12,22);
        pillar =new Pillar (bottom,58);  //pillar是具有矩形底的柱体
        System.out.println("矩形底的柱体的体积"+pillar.getVolume());
        bottom=new Circle(10);
        pillar =new Pillar (bottom,58); //pillar是具有圆形底的柱体
        System.out.println("圆形底的柱体的体积"+pillar.getVolume());
    }
} 

接口定义、继承和实现

 

接口中的方法