java代码实践

IfStudent 接口完整代码如下

package test;

public interface IfStudent {
void setFee(int fee);
int getFee();
}

IfTeacher 接口完整代码如下
package test;

public interface IfTeacher {
void setPay(int pay);
int getPay();
}

JobGraduate 类完整代码如下

package test;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Random;

public class JobGraduate implements IfStudent, IfTeacher , Serializable {

private int fee;
private int pay;
private String name;
private int age;
public JobGraduate() 
{
}
public JobGraduate(String name)
{
this.name = name;
}
@Override
public void setFee(int fee) {
// TODO Auto-generated method stub
this.fee = fee;
}

@Override
public int getFee() {
// TODO Auto-generated method stub
return fee;
}

@Override
public void setPay(int pay) {
// TODO Auto-generated method stub
this.pay = pay;
}

@Override
public int getPay() {
// TODO Auto-generated method stub
return pay;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public int getAge() {
return age;
}

public void setAge(int age) {
this.age = age;
}
public String toString()
{
StringBuilder sb = new StringBuilder();
sb.append("姓名：").append(this.name).append("\n")
.append("月薪：").append(this.pay).append("\n")
.append("费用：").append(this.fee).append("\n");
return sb.toString();
}

public static void main(String[] args) {
// TODO Auto-generated method stub
Random r = new Random();
try(
FileOutputStream f = new FileOutputStream(new File("test.dat"));
ObjectOutputStream of = new ObjectOutputStream(f);
)
{
for(int i = 1;i<=10;i++)
{
JobGraduate g = new JobGraduate("张"+i);
g.setAge(20+r.nextInt(21));
g.setFee(5000+r.nextInt(3001));
g.setPay(4000+r.nextInt(4001));
System.out.println(g);
of.writeObject(g);
if((12*g.getPay()-2*g.getFee())<50000)
throw new RuntimeException("需要贷款");
else
System.out.println("不需要贷款");
}
}
catch(IOException e)
{
e.printStackTrace();
}
}
} 

package com.suct.text;				//包格式，位于整个程序首行
//行注释	/*多行注释*/	/**文件注释*/
默认命名规则 ：	常量：COLOR_BLUE	类名：GoodMan	方法：getName	变量：lightYear、
import java.util.random;	    //引入
public class Welcome{
   	 public static void main(String[] args){
		System.println("HelloWorld!");
		int age = 18;
		System.println("age:"+age);
		System.println(“age:”+(age*12));			//在输出中运算  }       }

局部变量：方法中声明，属于方法 成员变量：在类中声明，属于对象 静态变量：在类中声明，用static修饰，属于类
final：用final修饰的变量为常量(需初始化)，如final int A = 10; 修饰的方法不可被改写 修饰的类不可被继承
boolean：布尔型 boolean a = true|false;
条件运算符：布尔表达式?y:z;如果表达式为true，返回y，如果表达式为false，返回z
输入类scanner：import java.util.scanner; Scanner s = new Scanner(System.in); String name = s.nextLine(); int a =s.nextInt(); double b = s.nextDouble();
随机数：import java.util.Random; Random rand = new Random(); int a = rand.nextInt(); int a = rand.nextInt(5)+1;//生产一个0~5的随机整数
if(布尔表达式){语句块;} if(布尔表达式){语句块;}else{语句块;} if(布尔表达式){语句块;}else if(布尔表达式){语句块;} else{语句块;}
switch(表达式){ //表达式的值为int、枚举、字符串
case 值1：语句块1;break;
case 值2：语句块2;break;
default: 默认语句块; }
while(布尔表达式){循环体;i++;}
do{循环体;i++;}while(布尔表达式);
for(int i = 0;i<n;i++){循环体;} for(int i = 0;i<n;i++){ for(int i = 0;i<n;i++){循环体;}循环体;} //循环嵌套
break跳出整个循环 continue：结束本次循环，继续下一次循环
方法声明/定义：[修饰符1 修饰符2]返回值类型 方法名(形参){语句;} 普通方法调用：对象名.方法名(实参) 静态方法调用：类名.方法名(实参)
方法重载：只是方法名相同的方法其 实参个数、类型和顺序不同。
类的定义：public class 类名{} //可以定义多个类，用class修饰，但只能有一个public类，并且文件名和这个类相同。一个类中包含成员变量、方法和构造函数
构造函数：与类名同名的函数，无返回值类型，默认构造函数无参数，如果重载构造函数，则没有默认构造函数。构造函数通过new调用，用于创建对象，返回值是对象的地址，构造函数内不能有return 构造函数前面可以加修饰符修饰(封装)
this关键字：代表当前对象的地址 public void user(int x){this.x = x;} //类中包含成员变量x，把方法的形参x赋给类的x this(可带参数)用于调用重载的构造函数，必须位于新建构造函数的第一句
继承：一个类(子类)得到另一个类(父类)的全部结构，除了构造函数(只能单继承) 格式：class A extends B{ … }
组合：在一个类中建立另一个类的对象，在该类中调用创建对象的成员 has…a的关系
super关键字：对父类对象的引用，可以通过super来访问子类中被覆盖的父类的属性和方法，使用super调用普通方法没有限制，但是在构造函数中，第一行如果没调用super()或this()，会默认调用super()，含义是调用父类的无参数构造函数
多态：在子类中函数被重写，但是形参如果是父类时，可以根据实参类型调用子类或父类的被重写的函数
抽象类：用abstract修饰的的类必定至少有一个abstract修饰的方法，其他不限，abstract修饰的方法只有声明没有实现。抽象类被继承extends后子类必须实现父类抽象类中的抽象方法，抽象类不能实例化。抽象类可以有构造函数，但是无法被new调用，只能被子类super调用
接口：用interface修饰的类是接口类，接口类中只能包含常量和接口函数，不能包含其他。接口类通过implements关键字被子类实现。接口类可以继承多个父接口类 [修饰符]interface A extends B,C{}