java学习个人总结_学习JAVA自我总结

1.对于静态方法(static)只能使用静态变量，而实例方法既能使用静态变量也能使用实例变量。

2.对于创建类时使用类的构造方法赋初值：类名 xxx=new 类名("","",...)

实例测试：

public class Test {

public static int a;  //静态变量

public int b;        //实例变量

Public Test(){}

Public Test(int a,int b){this.a=a;this.b=b;}   //构造方法赋初值

public static void printab() {System.out.println(a+" "+b);}//编译时有错误

public void  printab_() {System.out.println(a+" "+b);}//没有错误

public static void main(String args []) {

Test test=new Test(1,2);

test.printab_();

test.printab();

}

}

运行截图：

结果分析：实例方法即可使用实例变量也能使用静态变量。而静态方法只能使用静态变量。

()对于静态类如何访问实例变量呢？

示例代码

public class Test {

public static int value=100;

public int a;

public Test() {}

public Test(int a) {value=a;}

public static int geta(int aa) {return aa;}

public static void main(String args []) {

Test test1=new Test();

test1.a=test1.value;

System.out.println(test1.geta(test1.a));

}

}

截图

类的封装，实质把类的变量设置为私有变量，不可以被外界更改，而设置和获取变量的值都用类的方法来实现。

代码示例

public class Test {

private static int a;

public static void seta(int b) {a=b;}

public static int geta() {return a;}

public static void main(String args []) {

Test test=new Test();

test.seta(5);

System.out.println(test.geta());

}

}

运行截图

类与对象

当声明一个对象时，myclass xxx；并没有为该对象分配内存，实际是myclass xxx=null；

而myclass xxx=new myclass();则为xxx分配了内存，当xxx不被使用时系统会自动销毁其占用的内存。

myclass xxx=new myclass()；myclass yyy=xxx；实际是把xxx的地址赋给yyy，即xxx和yyy共用内存。

示例代码

public class Test {

int value=100;

public static void main(String args []) {

Test test1=new Test();

Test test2=new Test();

System.out.println(test1==test2);

}

}

结果为false，因为test1和test2两个对象的内存地址不同。

跟踪一个类，随时知道它所创建对象的个数。

我们采用在类中定义一个静态的的变量s，在类的构造方法中对s进行+1，如下代码：

//System.out.println

public class Test {

public static int s=0;

public Test() {s++;System.out.println("你已经创建了"+s+"个Test对象！");}

public static void main(String args []) {

Test a=new Test();

Test a1=new Test();

Test a2=new Test();

Test a3=new Test();

Test a4=new Test();

Test a5=new Test();

}

}

截图：

关于string类常用的方法

代码：Mypackage->Stringtest

着重两个方法一个是把int型等数字转换为字符串

Int a=20171121；String str=String.valueOf(a)；

一个把字符串逆置，需要用到StringBuffer

str=“asdfghjkl”；StringBuffer sb=new StringBuffer(str)；

sb.reserve().toString()；//完成逆置

常用的方法还有

str.length();

str.charAt(int n);

Str.indexOf(char c);

Str.toUpperCase();

Str.toLowerCase();

等下面截图中一一举例

截图：

关于流Stream与文件

演示一些文件的基本操作：

File.getClass();//得到文件的类名

File.getName();//文件名

File.getAbsolutePath();//绝对路径

File.length();//文件大小((以字节为单位)

String s[]=File.list();//文件夹的对象列表

S.length//为文件夹下有多少个对象

【1】最基本的FileInputStream和FileOutputStream

(1)利用FileInputStream读入文件内容

第一步：创建对象：FileInputStream fin=new FileInputStream(“指定文件名”);

第二步：建立一个byte数组： byte date[]=new byte[1024];

第三步：把数据读入数组date：fin.read(date);

第四步：输出的屏幕：System.out.print(new String(date,0,date.length));

第五步：关闭的对象：fin.close();

(2)利用FileOutputStream写入数据到文件

第一步：创建对象：FileOutputStream fout=new FileOutputStream(“文件名”);

第二步：输入数据：如int a=20163664 //String b=”赵永真”；//

第三步：写入文件：fout.write(String.valueOf(a).getBytes());//把int转String//

第四步：关闭：fout.close();

源代码：

File f=new File("test.txt");//在项目目录下新建一个文件

FileInputStream fis=new FileInputStream(f);//创建一个输入流对象指向该文件

FileOutputStream fos=new FileOutputStream(f);//创建一个输出流对象指向该文件

byte date[]=new byte[1024];//新建一个byte数组用来读取数据

String a="赵永真";

int b=20163664;

fos.write(a.getBytes());//把字符串数据写入文件

fos.write("  ".getBytes());//把空格写入文件

fos.write(String.valueOf(b).getBytes());//先把int型数据转为字符串在写入文件

fis.read(date);//利用输入流对象读入文件里的数据到数组date

System.out.println(new String(date,0,date.length));//把byte数组的数据以字符串的形式输出

fis.close();//关闭

fos.close();//关闭

截图：

【2】字符流FileWriter与FileReader

注意：不可以一边写一遍读！！！！！！！！！！！！！

(1)利用FileReader读入文件内容

第一步：创建对象：FileReader fr=new FileReader (“指定文件名”);

第二步：建立一个char数组： char date[]=new char[1024];

第三步：把数据读入数组date：fr.read(date);

第四步：输出的屏幕：System.out.print(new String(date,0,date.length));

第五步：关闭的对象：fr.close();

源代码

FileReader fr=new FileReader("poem.txt");

char []date=new char[32];

int i=0;

while((i=fr.read(date))>0)

{System.out.println(new String(date,0,i));}

fr.close();

截图

(2)利用FileWriter写入数据到文件

第一步：创建对象：FileWriter fw=new FileWriter(“文件名”);

第二步：输入数据：如int a=20163664 //String b=”赵永真”；//

第三步：写入文件：fw.write(String.valueOf(a));//把int转String//

第四步：关闭：fout.close();

源代码

//FileWriter fw=new FileWriter(f);

//fw.write("石家庄铁道大学 ");

//fw.write("信息科学与技术学院 ");

//fw.write("信1603班 ");

//fw.write("学号20163664 ");

//fw.write("姓名赵永真 ");

//fw.close();

截图同上

【3】RandomAccessFile

第一步：建立对象：RandomAccessFile ran=new RandomAccessFile(“文件名”,”rw”)；//rw为读写的方式

第二步：写入数据：ran.writeChars(“赵永真”);

ran.writeInt(20163664);

第三部：建立一个byte数组：byte date[]=new byte[(int)ran.length()];

(重点)第四步：找到读取的位置ran.seek(0);从0开始读入

第五步：ran.read(date);//读入数组

第六步：关闭：ran.close();

源代码

File f=new File("11221.txt");

RandomAccessFile ran=new RandomAccessFile(f,"rw");

String name="赵永真";

int id=20163664;

ran.writeChars(name);

ran.writeChars("    ");

ran.writeChars(String.valueOf(id));

byte date[]=new byte[(int)ran.length()];

ran.seek(0);

ran.read(date);

String str=new String(date,"gbk");

System.out.println(str);

ran.close();

截图

8.继承与多态

(1)通过final声明的父类的方法不可以更改。

通过final声明的方法和变量等都不可修改。

(2)子类继承父类时，构造方法的继承。

Class A{

Private String name;

Private int age;

Public A(){}

Public A(String name,int age){this.name=name;this.age=age;}

}

Class B extends A{

Private int id;

Public B(){}

Public B(String name,int age,int id){super(name,age);this.id=id;}

}

(3) 抽象类，通过abstract修饰如abstract class A{} .

抽象类不可以创建对象，类似于接口，它的作用需要通过子类继承实现。

抽象类可以有抽象的方法，也可以没有。如果有，所以的抽象方法必须通过子类重新定义。格式：public abstract String getA();//注意：没有中括号

(4)接口public interface A{public void cook();}

class B implements A{

Public void cook(){

//类似于抽象方法必须写出实体

}

}

(5)一个类可以实现多个接口，但只能继承一个父类

9.异常处理

(1)格式try{

//可能发成运行错误的代码

}catch(异常类型(Exception) 异常对象的引用){

//用于处理异常的代码

}

Finally{

//不管出不出错都会执行的代码

}

(2)当一个方法包含throws子句时，必须通过try/catch/finally进行捕获。

Void add()throws Exception{

Try{}catch(Exception e){}finally{}

}

(3) 自定义异常

所有自定义异常类必须继承Exception类

Class ErrorException extends Exception{

Public ErrorException(String s)

{super(s);}

}