java se基础复习1

Java两种核心机制:java虚拟机垃圾收集机制

源程序(*.java)---java编译器---字节码(*.class)—操作系统平台

Java虚拟机可以理解成一个字节码为机器指令的cpu

对于不同的运行平台,有不同的虚拟机

Java虚拟机制屏蔽了底层运行平台的差别,实现了”一次编译,随处运行”

Java是解释型语言

J2SDK(软件开发包) JRE(java运行环境) 开发需要JDK 用户需要JRE

Bin二进制

Dos中输入java –version现在用的jdk版本

Path:window系统执行命令时要搜寻的路径

Classpath:java在编译和运行时要找的class所在的路径

1.Helloworld.java

Public class HelloWorld{

Public static void main(String[] args){

System.out.println(“HelloWorld”);

}

cd java//切换到java目录

javac HelloWorld.java

java HelloWorld

详细信息工具文件夹应用到所有文件夹

显示所有文件和文件夹

不隐藏已知文件类型拓展名

在地址栏显示完整路径

类体方法体

一个原文件中最多有一个public类每个类对应一个class

源文件的名必须和public类名相同

Java语言注释三种注释方式:

/* */

/**

Java.lang.NoclassDefound

IDE集成开发环境

J2se基础语法

标识符:凡是自己可以起名字的由字母下划线美元符或数字组成

应以字母,数字,美元符

见名知意

关键字:专门用途,小写英文

Java常量:用字符串表示,区分为不同的类型

Eg 整型常量123

实型常量3.14

字符常量’a’

逻辑常量true false

字符串常量”helloworld”

“常量”这个名词还会用在另外其它语境中表示值不可变的变量参见Final关键字

Java变量是程序中最基本的存储单元,其要素包括变量名,变量类型和作用域

Java程序中每一个变量都属于特定的数据类型,在使用前必须对其声明.

从本质上讲,变量其实是内存中的一小块区域,使用变量名来访问这块区域,因此,每一个变量使用前必须要先申请(声明),然后必须进行赋值(填充内容),才能使用.

程序执行过程 load到内存找到main方法开始执行

执行过程管理:code segment存放代码 data segment 静态变量字符串常量

Stack局部变量 heap new出来的东西(内存分的四部分)

Java变量的分类

按被声明的位置划分:

局部变量:方法或语句块内部定义的变量(包含方法参数)

成员变量:方法外部,类的内部定义的变量

类外面不能有变量的声明

大括号里声明的变量,出了大括号就没人认识大括号里声明的变量

按所属的数据类型划分:

基本数据类型变量4类8种

逻辑型boolen true false 不可以以0或非0的整数替代

文本型字符型char \u后边的数是十六进制的编码 \n换行符 \r回车符

整数型 byte1 short1 int4 long8 八进制0开头十六进制 0x 或0X开头×××默认为int型,声明long型常量可以后加l或L

浮点数型两种表示形式十进制科学记数

Float4 double8 默认double声明float型常量可以后加f或F

引用数据类型变量

基本数据类型转换:boolean不可以转换为其他数据类型

×××,字符型,浮点型在混合运算中相互转换

Infinity无小的转换成大的自动转化大的转换成小的强制转换

Byte short char 转换成int处理

程序应该主义的问题

1. 大括号对其

2. 遇到{缩进,Tab/shift+Tab

3. 程序块之间加空格

4. 并排语句之间加空格

5. 运算符两侧加空格

6. {前面有空格

7. 成对编程

运算符

算术运算符逻辑运算符赋值运算符字符串连接符

“+”运算符两侧的操作数中只要有一个是字符串类型,系统会自动将另一个操作数转换为字符串然后在进行连接

当进行打印的时候,无论任何类型都自动转换为字符串进行打印

Print不换行 println换行

表达式

表达式的类型和值表达式的运算顺序

三目条件运算符 x?y:z x 为boolean类型为true结果为y 否则为z

语句

条件语句

If..else..

If..else if..else..

For循环语句

1+3+5+…+99

public class OddSum{

long result = 0;

for(int i=1; i<=99; i+=2){

result +=i;

System.out.println(“result=”+restult);

}

Int result=0;

For(int i=1;i<=99;i+=2)

{result+=i}

Tab shift+tab

While do while

Break continue

1 100内前5个可以被3整除的数

输出101 200内的质数

应该由哪些类对象

应该具有的属性方法

类和类之间的关系

Static关键字

用static声明的成员变量为静态成员变量,它为该类的公用变量,在第一次使用时被初始化,对于该类的所有对象来说,static成员变量只有一份.

可以通过对象引用或类名(不需要实例化)访问静态成员

用static声明的方法为静态方法,在调用该方法时,不会将对象的引用传递给它,所以在static方法中不可访问非static的成员.静态方法不再是针对于某个对象调用,所以不能访问非静态成员

Package 和import语句

class文件的最上层包的父目录位于classpath下

执行一个类需要写全包名

J2SDK

Java.lang 包含一些java语言的核心类,如string,math,integer,system和thread,提供常用功能

Java.awt 包含了构成抽象窗口工具集的多个类,这些类被用来构建和管理应用程序的图形用户界面(GUI)

Java.applet包含applet运行所需的一些类

Java.net 包含执行与网络相关的操作的类

Java.io 包含能提供多种输入/输出功能的类

Java.util 包含一些实用工具类,如定义系统特性,使用与日期日历相关的函数

Java.lang不需引入

Dos中打jar包的命令 jar –cvf xx.jar *.*

继承和权限控制

Extends

通过继承,子类自动拥有了基类的所有成员(成员变量和方法)

Java只支持单继承,不允许多继承.一个子类只能有一个基类一个基类可以派生多个子类

Private 类内部

Default 类内部同一个包

Protected 类内部同一个包子类

Public 类内部同一个包子类任何地方

方法的重写

在子类中可以根据需要从基类中继承来的方法进行重写

重写方法和被重写方法具有相同方法名称,参数列表和返回类型

重写方法不能使用比被重写方法更严格的访问权限

Super关键字

在java类中使用super来引用基类的成分,eg 引用方法

继承中的构造方法

子类的构造过程中必须调用其基类的构造方法

子类可以在自己的构造方法中使用super调用基类的构造方法

使用this调用本类的另外的构造方法

如果调用super,必须写在子类构造方法的第一行

如果子类的构造方法中没有显示的调用基类构造方法,则系统默认调用基类无参数的构造方法

如果子类构造方法中既没有显式调用基类构造方法,而基类中又没有无参的构造方法,则编译出错.

Object类

Object类是所有java类的根基类

Clone()

equals(Object obj)

finalize()

getClass() 拿到编译好的class文件

hashCode()

notify()

toString() 返回代表这个对象的字符串

toString方法

object 类中定义有public String toString()方法,其返回值是String类型,描述当前对象的有关信息.

在进行String与其它类型数据的连接操作是(如:System.out.println)(“info”+person),将自动调用该对象类的toString()方法.

可以根据需要在用户自定义类型中重写toString()方法.

Public class TestToString{

Dog d = new Dog();

System.out.println(“d:=”+d.toString); //object类默认是哈希编码

}

Class Dog{

Public String toString(){

Return “I’m a cool Dog!”

哈希编码: 独一无二的代表一个对象.并且通过哈希编码可以独一无二的找到这个对象的位置.

在java虚拟机运行时需找到运行对象的地址,会用一张表记录每一个对象的位置,根据编码可以找到对象.

equals()方法

重写Public boolean equals(Object obj){}

public class TestEquals{

public static void main(String[] args){

Cat c1 = new Cat(1,2,3);

Cat c2 = new Cat(1,2,6);

System.out.println(c1 = c2); //比较的是引用中的内容,不可能相同

System.out.println(c1.equals(c2));

//上为object类

//下为string类 string类中的equals方法序列一样就相等

String s1 = new String(“hello”);

String s2 = new String(“hello”);

System.out.println(s1 ==s2);

System.out.println(s1.equals(s2));

Class Cat{

Int color;

Int height,weight;

public Cat(int color,int height,int weight){

this.color = color;

this.height = height;

this.weight = weight;

Public boolean equals(Object obj){

if(obj = = null) return false;

else{

if(obj instanceof Cat){

Cat c = (Cat) obj;

If(c.color==this.color&&c.height==this.height&&c.weight ==this.weiget)

Return true;

Return false;

Object 的equals方法定义为:x.equals(y) 当x和y是同一个对象的应用是返回true否则返回false.

对象转型(casting)

一个基类的引用类型变量可以”指向”其子类的对象.

一个基类的引用不可以访问其子类对象新增加的成员(属性和方法)

可以使用引用变量instanceof 类名来判断该引用型变量所指向的对象是否属于该类或该类的子类

子类对象可以当做基类的对象来使用称作向上转型(upcasting),反之称为向下转型(downcasting).

动态绑定和多态

动态绑定是指在执行期间(而非编译期)判断所引用对象的实际类型,根据其实际的类型调用其相应的方法.

实际中new的谁就调用谁的方法,实际中的地址才会绑定到相应方法之中的地址上面

多态的条件:

1 有继承 2 有重写 3 父类引用指向子类对象

多态特性对于系统可扩充性有重要影响

抽象类

用abstract关键字来修饰一个类时,这个类叫做抽象类,用abstract来修饰一个方法时,该方法叫做抽象方法.

含有抽象方法的类必须被声明为抽象类,抽象类必须被继承,抽象方法必须被重写.

抽象类不能被实例化

抽象方法只需声明,不需实现

Eg:public abstract void enjoy();

Final关键字

Final的变量值不能够被改变

Final的成员变量

Final的局部变量(形参)

Final的类不能够被继承

Final的方法不能够被重写

Public class TestFianl{

Public static void main(String[] args){

T t = new T();

t.i = 9;

Final Class T{

Final int t = 8;

Public final void m(final int j){

Class TT extends T{

Public void m(){

接口interface

多个无关的类可以实现同一个接口

一个类可以实现多个无关的接口

与继承关系类似,接口与实现类之间存在多态性

接口是抽象方法和常量值的定义的集合

从本质上讲,接口是一种特殊的抽象类,这种抽象类中只包含常量和方法的定义,而没有变量和方法的实现

接口特性

接口可以多重实现

接口中声明的属性默认为public static final 的;也只能是public static final 的;

接口中只能定义抽象方法,而且这些方法默认为public的,也只能是public的;

接口可以继承其它的接口,并添加新的属性和抽象方法.

异常处理

运行期出现的错误

Eg: int[] a = {1,2,3};

Try{

System.out..println(arr[4]);

Catch(ArrayIndexOutofBoundsException ar){

System.out.println(“系统正在维护”);

ar.printStackTrace();

Java.lang.ArrayIndexOutofBoundsException 数组下标越界

printStackTrace();

j2sdk中定义了很多异常类

Throwable (1)error 不可处理(2)exception / RuntimeException经常出现的错误,可以捕获也可以不捕获./另一类必须被catch

Try{}

Catch(someException1 e){}

Catch(someException2 e){}

Finally{}//通常在其中进行资源的清除工作

Void f() throws FileNotFoundException,IOException{}

Void f2(){

Try{

f(0);

}catch(FileNotFoundException e){

System.out.println{e.getMessage()}}

Catch(IOException e){

e.printStackTrace();}

ArithmeticException

Try catch finally throws throw

使用自定义异常一般有如下步骤;

1 通过继承java.lang.Exception类声明自己的异常类

2 在方法适当的位置生成自定义异常的实例,并用throw语句抛出

3 在方法的声明部分用throws语句声明该方法可能抛出的异常

注意:重写方法需要抛出与原方法所抛出异常类型一致异常或不抛出异常

数组

一维数组的声明方式: type var[] 或type[] var

数组对象的创建:

Java中使用关键字new创建数组对象,格式为:数组名 = new 数组元素的类型 [数组元素的个数]

Eg public class test{

Public static void main(String args[]){

Int[] s;

S = new int[5];

For(int i = 0; i < 5; i++){

S[i] = 2*i+1;

注意:数组元素为引用数据类型的数组中的每一个元素都需要实例化.

Public class Test{

Date[] days;

days=new Date[3];

for(int i=0;i<3;i++){

days[i]=new Date(2004,4,i+1);

class Date{

int year; int month; int day;

Date(int y, int m, int d){

Year = y;

Moth = m;

Day = d;

数组初始化

动态初始化:数组定义与为数组元素分配空间和赋值的操作分开进行.

Eg public class Test{

Public static void main(String args[]){

Int a[];

A = new int[3];

A[0]=3,a[1]=9,a[2]=8;

Date days[];

Days = new Date[3];

Days[0]=new Date(1,4,2004);

Days[1]=new Date(2,4,2004);

Days[2]=new Date(3,4,2004);

Class Date{

Int year,month,day;

Date(int y,int m,int d){

year=y,month=m,day=d;

静态初始化:在定义数组的同时就为数组元素分配空间并赋值.

Public class test{

Int a[] = {3,9,8};

Date days[] = {new Date(1,4,2004), new Date(2,4,2004),new Date(3,4,2004)}

数组元素的默认初始化

数组是引用类型,它的元素相当于类的成员变量,因此数组分配空间后,每个元素也被按照成员变量的规则被隐式初始化.

Int a[] = new int[5];

Date[] days = new Date[3];

System.out.println(a[3]);

System.out.println(days[2]);

Class date{

Year=y;

Month=m;

Day=d;

输出结果:0,null

数组元素的引用

定义并用运算符new为之分配空间后,才可以引用数组中的每个元素,数组元素的引用方式为:arrayName[index]

Index可以为数组元素下标,可以是×××常量或×××表达式.eg a[3] b[i] c[6*i]

数组元素下标从0开始;长度为n的数组的合法下标取值范围为0~n-1

每个数组都有一个属性length指明它的长度,例如

a. length的值为数组a的长度(元素个数)

public class TestArray{

public static void main(String[] args){}

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

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

System.out.println(a[i] + “ ”);

For(int i=0;i<args.length;i++){

System.out..println(args[i]);

Public class TestArgs{

If(args.length<3){

System.out.println(“usage:java Test \”n1\” \”op\” \” n2\””);

System.exit(-1); //非正常退出

double d1 = Double.parseDouble(args[0]);

double d2 = Double.parseDouble(args[2]);

double d = 0;

if(args[1].equals(“+”)) d = d1+d2;

else if(args[1].equals(“-”)) d = d1-d2;

else if(args[1].eauals(“×”)) d=d1*d2;

else if(args[1].equals(“/”)) d=d1/d2;

else{

System.out.println(“Error operator!”);

System.exit(-1);

System.out.println(d);

*******************

Public class NumSort{

int[] a = new int[args.length];

//读进来

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

a[i] = Integer,parseInt(args[i]);

print(a);

selectionSort(a);

Private static void selectionSort(int[] a){

int k,temp;

For(int i=0;i<a.length;i++){

k = i;

for(int j=k+1;j<a.length;j++){

If(a[j]<a[k]){

k = j;

If(k!=i){

temp=a[i];

a[i]=a[k];

a[k]=temp;

Private static void print(int[] a){

System.out.print(a[i] + “ “);

System.out.println();

Date[] days = new Date[10];

Date day = new Date(2004,4,6);

Int year,month,day;

Date(int y,m,d){}

二维数组

可以看成以数组为元素的数组

多维数组的声明和初始化应该按从高维到低维的顺序进行.

Eg int a[][] = new int[3][ ]

A[0] = new int[2];

A[1] =new int[4];

A[2] = new int[3]

数据的拷贝

使用java.lang.System类的静态方法

Public static void arraycopy(object src,int srcPos,object dest,int destPos,int length)

可以用于数组src从第srcPos项元素开始的length个元素拷贝到目标数组从destPos项开始的length个位置.

如果源数据数目超过目标数组边界会抛出IndexOutOfBoundsException异常.

java se基础复习1

继续阅读

Java 学习心得（三）----继承与多态1.类、超类与子类2. 多态3. final 关键字4.抽象类5.自动装箱与拆箱6.可变长参数7.反射

权限控制、多态、接口学习心得

Qt 中实现在控件中点击鼠标，就在鼠标点击处加载图片的方法

Python入门笔记7 - 面向对象编程一、面向对象编程OOP二、类和对象三、数据封装四、继承五、多态六、获取对象信息

Java个人学习笔记心得之面向对象

JavaSE-------面向对象面向对象

通过字节码分析Java方法的静态分派与动态分派机制

记一次OC Block循环引用(Retain Cycle)引起的内存泄露

C++ virtual关键字

2. Java 类继承详解（知识点梳理总结）版本1、定义2、创建子类3、继承的基本规则4、阻止继承5、构造子类对象6、super 关键字

Java中传值与传址、static、继承、重写、super

浅谈Java static 关键字

java静态域和静态方法

java中的静态变量和静态方法

C++对象模型之继承与多态的探索

面向对象加强--静态和非静态