课时67:案例分析一(学生类)
补习一下this调用构造函数的例子:
public CrawlDatum(){}
public CrawlDatum(int status, int fetchInterval) {
this(); /*this调用的作用是调用上面的无参构造函数*/
this.status = (byte)status;
this.fetchInterval = fetchInterval;
}
public CrawlDatum(int status, int fetchInterval, float score) {
this(status, fetchInterval); /*this的作用是调用上面有两个参数的构造函数*/
this.score = score;
}
1, 实现代码复用。例如上面第三个构造函数如果不使用this就会是这样
public CrawlDatum(int status, int fetchInterval, float score) {
this.status = (byte)status;
this.fetchInterval = fetchInterval;
this.score = score;
}
这样的话,前两行代码就完全是第二个构造函数中的语句,违背面向对象代码复用的原则。
2, 封装 如果说第二个构造函数的实现发生了变化,则我们除了修改第二个构造函数,还得修改第三个构造函数。 如果使用this就不需要修改第三个构造函数了。
package test;
class Person {
private String name;
private String addr;
private char sex;
private int age;
public Person(){}
public Person(String name,String addr){
this(name,addr,'男',0);
}
public Person (String name,String addr,char sex,int age){
this.name = name;
this.addr = addr;
this.sex = sex;
this.age = age;
}
public String getInfo(){
return "姓名:"+ this.name + "、性别:" + this.sex+ "、年龄:"+ this.age +"、地址:"+ this.addr;
}
}
class Student extends Person{
private double match;
private double english;
public Student(){} //无参
public Student(String name , String addr){ //两参
super(name,addr);
}
public Student(String name,String addr,char sex,int age,double match,double english){ //六参
super(name,addr,sex,age);//重点!!! super应在首行调用
this.match = match;
this.english = english;
}
public String getInfo(){
return super.getInfo() + "、数学成绩:"+ this.match + "、英语成绩" + this.english ;
}
}
public class example {
public static void main(String[] args) {
Student stu = new Student("暖光","天府广场",'男',3,99.8,99.9) ;
System.out.println(stu.getInfo() );
}
}
/*
不能被继承的:
1.私有的属性(可以通过set get或super方法使用父类的私有属性)
2.不同包的friendly
3.构造方法不能继承
*/
课时68:案例分析二(管理人员与职员)
package test;
class Employee{
private String name;
private int age;
private String sex;
public Employee(){}
public Employee (String name,int age, String sex){
this.name = name;
this.age = age;
this.sex = sex;
}
public String getInfo(){
return "姓名:"+this.name+"、年龄:"+this.age+"、性别:"+this.sex;
}
}
class Manager extends Employee{
private String job;
private double yearSalary;
public Manager (){}
public Manager (String name,int age,String sex,String job,double yearSalary){ //继承父类此处也应该添加成员属性才可继承
super(name,age,sex);
this.job = job;
this.yearSalary = yearSalary;
}
public String getInfo(){
return "【管理层】:"+super.getInfo() + "、职务:"+this.job + "、年薪:"+this.yearSalary ;
}
}
class Worker extends Employee{
private String department;
private double monthSalary;
public Worker(){}
public Worker(String name,int age, String sex,String department,double monthSalary ){
super(name,age,sex);
this.department = department ;
this.monthSalary = monthSalary ;
}
public String getInfo(){
return "【职员】:"+super.getInfo() +"、部门:"+this.department +"、月薪:"+this.monthSalary ;
}
}
public class example {
public static void main(String[] args) {
Manager man = new Manager("张三",30,"男","主管",15000.00);
Worker str = new Worker("李斯",25,"女","出纳",3000.00);
System.out.println(man.getInfo());
System.out.println(str.getInfo());
}
}
课时69:案例分析三(字符串统计)
统计“want you to know one thing”字母“n”、“o”出现次数。
方案1:先做一个单独的处理类
补充:分析Java中的关键字static:https://baijiahao.baidu.com/s?id=1636927461989417537&wfr=spider&for=pc
package test;
class StringUtil{
/*
static方便在没有创建对象的情况下来进行调用。被static关键字修饰的不需要创建对象去调用,直接根据类名就可以去访问。
如果没有用static修饰count,则只能new 一个外部类实例。再通过外部实例创建内部类。
static是一个修饰符,用于修饰成员。(成员变量,成员函数)static修饰的成员变量 称之为静态变量或类变量。
static修饰的成员被所有的对象共享。
static优先于对象存在,因为static的成员随着类的加载就已经存在。
static修饰的成员多了一种调用方式,可以直接被类名所调用,(类名.静态成员)。
static修饰的数据是共享数据,对象中的存储的是特有的数据。
*/
public static int[] count(String str){
int countData [] = new int[2]; //相当于把两个用来统计的变量放一起了,其中就是countData[0]、countData[1]
char [] data = str.toCharArray(); //将一个字符串转换成一个Char型的字符数组
for (int x = 0;x<data.length;x++){
if(data[x] == 'n' || data[x] == 'N'){
countData[0]++;
}
if(data[x] == 'o' || data[x] == 'O'){
countData[1]++;
}
}
return countData;
}
}
public class example {
public static void main(String[] args) {
String str = "want you to know one thing";
int result[] = StringUtil.count(str) ;
System.out.println(result[0]);//n
System.out.println(result[1]);//o
}
}
方案2:用继承的方式统计
package test;
class StringUtil{
private String content;
public StringUtil(String content){
this.content=content;
}
public String getContent(){
return this.content;
}
public String getInfo(){
return this.getContent();
}
}
class StringCount extends StringUtil{
private int nCount;
private int oCount;
public StringCount(String content){
super(content);
this.countChar();
}
public void countChar(){
char [] data = super.getContent() .toCharArray(); //将一个字符串转换成一个Char型的字符数组
for (int x = 0;x<data.length;x++){
if(data[x] == 'n' || data[x] == 'N'){
this.nCount++;
}
if(data[x] == 'o' || data[x] == 'O'){
this.oCount++;
}
}
}
public int getNCount(){
return this.nCount ;
}
public int getOCount (){
return this.oCount ;
}
public String getInfo(){
return "字母N的个数"+ this.nCount +"、字母O的个数"+ this.oCount;
}
}
public class example {
public static void main(String[] args) {
StringCount sc = new StringCount("want you to know one thing") ;
System.out.println(sc.getInfo() );
}
}
课时70:案例分析四(数组操作)
1、实现基本的数组操作类定义
package test;
class Array{ //数组的操作类
private int[] data; //整形数组
private int foot; //进行数组的索引控制
Array(int len){
if(len > 0){
this.data = new int[len]; //开辟len个空间
} else {
this.data = new int[1]; //开辟一个空间。长度:也就是内部存储元素的数量
}
}
//实现数组容量的扩充,给出的是扩充大小;实际大小是:已有大小+扩充大小
public void increment(int num){
//数组特征(缺陷):长度固定,要扩充只有new一个数组
int newData [] = new int[this.data.length + num];
System.arraycopy(this.data,0,newData,0,this.data.length) ; //拷贝
this.data = newData ; //改变数组引用
}
public boolean add(int num){
if(this.foot < this.data.length){ //有位置:数组还没用满,还有多余的空间
this.data[this.foot++] = num;
return true;
}
return false;
}
public int [] getData(){
return this.data;
}
}
public class example {
public static void main(String[] args) {
Array arr = new Array(5);
System.out.println(arr.add(10));
System.out.println(arr.add(5));
System.out.println(arr.add(20));
System.out.println(arr.add(3));
System.out.println(arr.add(6));
arr.increment(3) ;
System.out.println(arr.add(1));
System.out.println(arr.add(7));
System.out.println(arr.add(0));
}
}
2、进行排序子类定义
package test;
class Array{ //数组的操作类
private int[] data; //整形数组
private int foot; //进行数组的索引控制
Array(int len){
if(len > 0){
this.data = new int[len]; //开辟len个空间
} else {
this.data = new int[1]; //开辟一个空间。长度:也就是内部存储元素的数量
}
}
//实现数组容量的扩充,给出的是扩充大小;实际大小是:已有大小+扩充大小
public void increment(int num){
//数组特征(缺陷):长度固定,要扩充只有new一个数组
int newData [] = new int[this.data.length + num];
System.arraycopy(this.data,0,newData,0,this.data.length) ; //拷贝
this.data = newData ; //改变数组引用
}
public boolean add(int num){
if(this.foot < this.data.length){ //有位置:数组还没用满,还有多余的空间
this.data[this.foot++] = num;
return true;
}
return false;
}
public int [] getData(){
return this.data;
}
}
class SortArray extends Array{
public SortArray(int len){
super(len);
}
public int[] getData(){
java.util.Arrays.sort(super.getData() );
return super.getData() ;
}
}
public class example {
public static void main(String[] args) {
SortArray arr = new SortArray(5);
System.out.println(arr.add(10));
System.out.println(arr.add(5));
System.out.println(arr.add(20));
System.out.println(arr.add(3));
System.out.println(arr.add(6));
arr.increment(3) ;
System.out.println(arr.add(1));
System.out.println(arr.add(7));
System.out.println(arr.add(0));
int result[] = arr.getData() ;
for(int temp : result ){
System.out.print(temp + "、");
}
}
}
3、定义反转子类
建立一个可以实现整形数组操作类(Array),而后在里面可以操作的数组的大小由外部来决定,而后在Array类里面需要提供有数组的如下处理:进行数据的增加(如果数据满了则无法增加)、可以实现数组的容量扩充、取得数组的全部内容。完成之后在此基础上再派生出两个子类:
数组排序类:返回的数据必须是排序后的结果;
数组反转类:可以实现内容的首尾交换。
for(int i:b) 在java 编程中的使用
这种有冒号的for循环叫做foreach循环,foreach语句是java5的新特征之一,在遍历数组、集合方面,foreach为开发人员提供了极大的方便。
foreach语句是for语句的特殊简化版本,但是foreach语句并不能完全取代for语句,然而,任何的foreach语句都可以改写为for语句版本。
foreach并不是一个关键字,习惯上将这种特殊的for语句格式称之为“foreach”语句。从英文字面意思理解foreach也就是“for 每一个”的意思。实际上也就是这个意思。
foreach的语句格式:
int a[] {1,2,3,4,5,6,7}
for(数组类型int 变量i :数组名a){
System.out.print(i);
}
int b[]={1,2,3,4,5,6};
public void showall(){
for(int i:b){
System.out.println(i);
}
}
package test;
class Array{ //数组的操作类
private int[] data; //整形数组
private int foot; //进行数组的索引控制
Array(int len){
if(len > 0){
this.data = new int[len]; //开辟len个空间
} else {
this.data = new int[1]; //开辟一个空间。长度:也就是内部存储元素的数量
}
}
//实现数组容量的扩充,给出的是扩充大小;实际大小是:已有大小+扩充大小
public void increment(int num){
//数组特征(缺陷):长度固定,要扩充只有new一个数组
int newData [] = new int[this.data.length + num];
System.arraycopy(this.data,0,newData,0,this.data.length) ; //拷贝
this.data = newData ; //改变数组引用
}
public boolean add(int num){
if(this.foot < this.data.length){ //有位置:数组还没用满,还有多余的空间
this.data[this.foot++] = num;
return true;
}
return false;
}
public int [] getData(){
return this.data;
}
}
class ReverseArray extends Array{
public ReverseArray(int len){
super(len);
}
public int[] getData(){
int center = super.getData().length / 2;
int head = 0;
int tail = super.getData().length - 1;
for(int x = 0; x<center; x++){
int temp = super.getData()[head];
super.getData()[head] = super.getData()[tail];
super.getData()[tail] = temp;
head++;
tail--;
}
return super.getData();
}
}
public class example {
public static void main(String[] args) {
ReverseArray arr = new ReverseArray(5);
System.out.println(arr.add(10));
System.out.println(arr.add(5));
System.out.println(arr.add(20));
System.out.println(arr.add(3));
System.out.println(arr.add(6));
arr.increment(3) ;
System.out.println(arr.add(1));
System.out.println(arr.add(7));
System.out.println(arr.add(0));
int result[] = arr.getData() ;
for(int temp : result ){
System.out.print(temp + "、");
}
}
}