2018-12-04
2018-12-05 本文已影响0人
坏坏坏坏坏
封装：对外不可见，外部不能直接访问，只能通过接口来修改和获取。
封装使用的关键字就是private
this关键字：特殊的变量，引用当前实例（对象）
构造方法的作用：初始化对象的属性，实例化出来的对象的属性的内容是指定的值，不再是默认值。
方法的重载：方法名相同，参数列表不同
static的使用方法
package day08;
import java.util.Date;
public class Student {
private int sid;//学号
private String sname;//姓名
private int age;//年龄
private boolean isMale;//性别 true:男 false:女
private Date birth;//生日
private int grade;//成绩
private static int count;//学生人数
static{
System.out.println("加载学生模板");
}
/**
* @param sid 表示学号
* @param sname 表示姓名
* @param age 表示年龄
* @param isMale 表示性别
* @param grade 表示成绩
*/
public Student(int sid,String sname,int age,boolean isMale,int grade){
this.sid = sid;
this.sname = sname;
this.age = age;
this.isMale = isMale;
this.grade = grade;
count++;
}
/**
* 无参的构造方法
*/
public Student(){
count++;
}
/**
* 获取学生数量
* 静态的成员方法里面不能使用非静态的成员
* @return
*/
public static int getCount() {
return count;
}
使用方法
（1）将人数的属性设置成static；
（2）有参数：参数列表中不需要加是static
（3）设置一个函数用来返回count值
父类和子类的应用
package day10;
/**
* 员工类
* @author yangzc
*
*/
public class Emp {
private long id;//工号
private String name;//姓名
private char gender;//性别
private double salary;//薪资
public Emp(){}
public Emp(long id, String name, char gender, double salary) {
super();//调用父类的无参构造方法
this.id = id;
this.name = name;
this.gender = gender;
this.salary = salary;
}
public void show(){
System.out.println(""+id+","+name+","+gender+","+salary);
}
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public char getGender() {
return gender;
}
public void setGender(char gender) {
this.gender = gender;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
}
package day10;
/**
* 项目经理类型
* @author yangzc
*
*/
public class PM extends Emp{
private int exp;//工作年限
private double bonus;//项目奖金
/**
* 无参构造方法
*/
public PM(){
setId(System.currentTimeMillis());
setName(""+System.currentTimeMillis());
setGender('男');
setSalary((int)(Math.random()*20000*100)/100.0);
exp=3;
bonus=3000.0;
}
/**
*
* @param id
* @param name
* @param gender
* @param salary
* @param exp
* @param bonus
*/
public PM(long id,String name,char gender,double salary,int exp,double bonus){
setId(id);
setName(name);
setGender(gender);
setSalary(salary);
this.exp = exp;
this.bonus = bonus;
}
public void show(){
System.out.println(""+getId()+","+getName()+","+getGender()+","+getSalary()+","+exp+","+bonus);
}
public int getExp() {
return exp;
}
public void setExp(int exp) {
this.exp = exp;
}
public double getBonus() {
return bonus;
}
public void setBonus(double bonus) {
this.bonus = bonus;
}
}
列如 员工表和程序员表
1.将员工的属性写出来；
2.写出一个无参数的列表 和一个有参数的列表
3.然后写出一个函数，打印出员工表的内容
1.将程序员继承员工表，将员工表中没有的属性写下来
2.写出一个无参数列表 和有参数列表
无参数列表：
因为父类的属性都是封装起来的，所以说没有办法直接调用，要直接使用set函数去修改，括号中直接填写要修改的内容；
有参数列表：
因为父类中的属性都是封装起来的，所以说参数列表中的内容写 父类的set函数去修改，括号中直接填写要修改的属性；
3.然后写出一个函数，打印出子类中的信息，父类的信息内容需要用get函数去调用；
4.通过主程序中去直接调用该函数，就可以得到父类以及子类中的值。
super关键字的用法
package day10;
/**
* 程序员类型
* @author yangzc
*
*/
public class SE extends Emp{
private int hot;
/**
* 无参的构造方法
*/
public SE(){
//调用父类的有参构造方法初始化对象的属性
super(System.currentTimeMillis(),""+System.currentTimeMillis(),'男',(int)(Math.random()*20000*100)/100.0);
hot=100;
}
/**
*
* @param id 保存输入的工号
* @param name 保存输入的姓名
* @param gender 保存输入的性别
* @param salary 保存输入的工资
* @param hot 保存输入的关注度
*/
public SE(long id,String name,char gender,double salary,int hot){
super(id,name,gender,salary);//调用父类的有参构造方法
this.hot = hot;
}
/**
* 显示程序员的基本信息
*/
public void show(){
System.out.println(""+getId()+","+getName()+","+getGender()+","+getSalary()+","+hot);
}
public int getHot() {
return hot;
}
public void setHot(int hot) {
this.hot = hot;
}
}
- super（）的作用：是指父类的构造方法的函数
1.软件中有自动编写的程序
2.无参列表：
super（）括号中需要写入父类相应属性的内容，填写进去
有参列表：
super括号中需要填入父类中相应的属性；
3.建立一个函数，将函数的中的属性内容打印出来，通过get函数 来获取父类的属性内容。
重写父类中的打印内容
如果子类中的函数内容与父类的打印内容的条件不符合，需要将在子类中的重新编译，但是函数名要与父类的函数名相同，要不然的话会报错。
