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);}
}