201871010123-吴丽丽《面向对象程序设计(Java)》第四周学习总结

项目 内容
这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/
这个作业的要求在哪里 https://www.cnblogs.com/nwnu-daizh/p/11552848.html
作业的学习目标

1. 掌握类与对象的基础概念,理解类与对象的关系;

2. 掌握对象与对象变量的关系;

3. 掌握预定义类Date、LocalDate类的常用API;

4. 掌握用户自定义类的语法规则,包括实例域、静态域、构造器方法、更改器方法、访问器方法、静态方法、main方法、方法参数的定义要求;(重点、难点)

5. 掌握对象的构造方法、定义方法及使用要求;(重点);

6. 理解重载概念及用法;

掌握包的概念及用法

第一部分:总结第四章理论知识

1.类与对象的基础概念

A:什么是类?

a)类是具有相同属性和行为的一组对象的集合

b)类(class)是描述对象的模板,它定义一类对象所能拥有的数据和能完成的操作,在面向对象的程序设计中,类是构造程序的基本单元。

c)每个类由一组结构化的数据(称作实例域)和在其上的一组操作(称为方法)构成。

B:什么是对象?

a)对象是具体实体,具有明确定义的状态和行为。

b)对象的三个主要特征:

-行为(behavior):可以对对象施加什么操作(方法)?

-状态(state):当施加哪些方法时,对象如何如何响应?

-标识(identity):如何辨别具体相同行为与状态的不同对象?

2.类与对象的关系

a)类是对象,事物的描述和抽象,是具有相同属性和行为的对象集合。对象则是该类事物的实例。    

b)类是一个静态的概念,类本身不携带任何数据。当没有为类创建任何对象时,类本身不存在于内存空间中。对象是一个动态的概念。每一个对象都存在着有别于其它对象的属于自己的独特的属性和行为。对象的属性可以随着它自己的行为而发生改变。

3.类之间的关系:

a)依赖(use-a):如果一个类中的方法操作了另一个类的对象,那么这个类就依赖于另一个类。

b)聚合(has-a):类A的对象包含类B的对象

c)继承(is-a):表示一个特定类和一个一般类之间的关系。一般来说,如果类A继承了类B,那么类A不仅继承了类B的方法和状态,而且还有属于自己的方法和状态。

4.预定义类的使用

a)已学过的预定义类:Math类、math类、String类、Scanner类等,掌握练习预定义类API的技术方法。

b)要使用预定义类的方法,只需知道方法名和参数即可,无需了解它的内部实现过程。

c)使用预定义类需要在程序开始处使用import命令导入该类所在的包路径。

5.对象与对象变量

1)对象

a)在OOP中,要想使用对象,需先构造对象,并初始化对象状态,然后通过对象调用类中的办法。

b)java中,用构造器(constructor)构造并初始化对象。

c)构造器是类中一个特殊方法,该方法名与类名相同。

d)构造并初始化对象的格式:

new 构造器名(参数)

2)对象变量

a)如果要多次使用初始化的对象,可将初始化的对象放在一个对象变量中。

格式: Date birthday = new Date();

b)对象变量保存了对象后,可用对象变量引用对象。

注:对象变量不能空引用。也可以显示的将变量对象设置为null,表面这个对象变量目前没有引用任何对象。

6.用户自定义类

(1)类的定义包括两部分内容:声明和类体

(2)类体由两部分构成:

一为实体域(或成员变量)定义;二为方法定义。

(3)域的定义

a)实例域(成员变量):类定义时实例域部分所定义的变量。实例域在整个类内都有效。

b)局部变量:方法体中定义的变量和方法的参数。只在定义它的方法内有效。

(4)实例域的隐藏性

局部变量与实例域名字相同时,则实例域被隐藏,即在这个方法内暂时失效。

7.掌握用户自定义类的语法规则,包括静态域、构造器方法、更改器方法、访问器方法、静态方法、main方法、方法参数的定义要求

a)实例域:可将实例域定义为final,构建对象时必须初始化这样的域。

b)静态域:绝大多数面向对象程序设计语言中,静态域被称为类域。如果将域定义为static,每个类中只有一个这样的域。而每个对象对于所有的实例域却都有自己的一份拷贝。

c)静态方法:静态方法是一种不能向对象实时操作的方法。可以使用对象或类名调用静态方法。

d)构造器方法:构造器与类同名。构造器总是伴随着new操作符的执行被调用,而不能对一个已经存在的对象调用构造器来达到重新设置实例域的目的。

e)更改器方法:一个类中对实例域进行修改的方法,通常更改器方法名前缀为set。调用更改器方法后对象的状态会改变。

f)访问器方法:只访问对象而不修改对象的方法。

g)main方法:main方法不对任何对象进行操作。静态的main方法将执行并创建程序所需要的对象。

8.重载

多个方法有相同的名字、不同的类型、不同的参数、便产生了重载。Java允许重载任何方法,而不只是构造器方法。

9.包

1)Java允许使用包将类组织起来。借助包可以方便地组织自己的代码,并将自己的代码与别人提供的代码库分开管理。而且使用包可以确保类名的唯一性。

2)包作用域

a)类中标记为public的部分可以被任意类使用;

b)类中标记为private的部分只能在类中使用;

c)如果没有为类、方法或实例域指定访问控制修饰符public或private,这部分可以被同一包中的所有方法访问。

10.文档注释技术

a)类注释

b)方法注释

c)域注释

d)通用注释

e)包与概述注释

第二部分:实验部分

实验名称:实验三 类与对象的定义及使用

1.  实验目的:

(1) 熟悉PTA平台线上测试环境;

(2) 理解用户自定义类的定义;

(3) 掌握对象的声明;

(4) 学会使用构造函数初始化对象;

(5) 使用类属性与方法的使用掌握使用;

(6) 掌握package和import语句的用途。

2.实验步骤与内容

实验1 任务1

公民身份证号码按照GB11643—1999《公民身份证号码》国家标准编制,由18位数字组成:前6位为行政区划分代码,第7位至14位为出生日期码,第15位至17位为顺序码,第18位为校验码。从键盘输入1个身份证号,将身份证号的年月日抽取出来,按年-月-日格式输出。注意:输入使用Scanner类的nextLine()方法,以免出错。

输入样例:

34080019810819327X

输出样例:

1981-08-19

程序代码如下:

import java.util.Scanner;

public class Main {

	public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
System.out.println("please input your ID:");
String s1 = in.nextLine();
String s2,s3,s4;
s2 = s1.substring(6, 10);
s3 =s1.substring(10, 12);
s4 = s1.substring(12, 14);
System.out.println(s2+"-"+s3+"-"+s4); } }

  程序运行如下:

实验1 任务二

studentfile.txt文件内容是某班同学的学号与姓名,利用此文件编制一个程序,将studentfile.txt文件的信息读入到内存,并提供两类查询功能:(1)输入姓名查询学号;(2)输入学号查询姓名。要求程序具有友好人机交互界面。

编程建议:

(1)从文件中读入学生信息,可以编写如下函数:

public static void StudentsFromFile(String fileName))

(2)输入姓名查找学生学号,可以编写如下函数:

public static String findStudent(String name)

(3)输入学号查找学生姓名,可以编写如下函数:

public static String findStudent(String ID)

程序代码如下:

package Package;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner; public class Main {
private static Student students[];
public static void main(String[] args) {
students=new Student[];
Scanner in = new Scanner(System.in);
try {
readFile("studentfile.txt");
System.out.println("请选择操作,1按姓名,2按学号,3退出");
int i;
while ((i = in.nextInt()) != ) {
switch (i) {
case :
System.out.println("请输入姓名");
String name = in.next();
Student student = findStudentByName(name);
if (student == null) {
System.out.println("没找到");
} else {
System.out.println(student.toString());
}
System.out.println("请选择操作,1按姓名,2按学号,3退出");
break;
case :
System.out.println("请输入学号");
String id = in.next();
Student student1 = findStudentById(id);
if (student1 == null) {
System.out.println("没找到");
} else {
System.out.println(student1.toString()); }
System.out.println("请选择操作,1按姓名,2按学号,3退出");
break; default:
System.out.println("输入有误");
System.out.println("请选择操作,1按姓名,2按学号,3退出");
break;
} }
} catch (IOException e) {
// TODO 自动生成的 catch 块
e.printStackTrace();
}finally {
in.close();
} } public static void readFile(String path) throws IOException {
FileReader reader = new FileReader(path);
BufferedReader br = new BufferedReader(reader);
String result;
int i=;
while ((result = br.readLine()) != null) {
Student student = new Student();
student.setName(result.substring());
student.setID(result.substring(,));
students[i]=student;
i++;
}
br.close();
} public static Student findStudentByName(String name) {
for (Student student : students) {
if (student.getName().equals(name)) {
return student;
}
}
return null; } public static Student findStudentById(String Id) {
for (Student student : students) {
if (student.getID().equals(Id)) {
return student;
}
}
return null; }
} class Student {
private String name;
private String ID; public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public String getID() {
return ID;
} public void setID(String iD) {
ID = iD;
} @Override
public String toString() {
// TODO 自动生成的方法存根
return "姓名是:" + name + "学号是:" + ID;
}
}

程序运行结果如下:

实验2 导入第4章示例程序并测试。

测试程序1:

l 编辑、编译、调试运行程序4-2(教材104页);

l 结合程序运行结果,掌握类的定义与类对象的用法,并在程序代码中添加类与对象知识应用的注释;

l 尝试在项目中编辑两个类文件(Employee.java、 EmployeeTest.java ),编译并运行程序。

l 参考教材104页EmployeeTest.java,设计StudentTest.java,定义Student类,包含name(姓名)、sex(性别)、javascore(java成绩)三个字段,编写程序,从键盘输入学生人数,输入学生信息,并按以下表头输出学生信息表:

姓名    性别 java成绩

程序4-2代码如下:

import java.time.*;     //导入java.time的包

/**
* This program tests the Employee class.
* @version 1.13 2018-04-10
* @author Cay Horstmann
*/
public class EmployeeTest
{
public static void main(String[] args)
{
// 用三个employee对象填充staff数组
Employee[] staff = new Employee[3]; staff[0] = new Employee("Carl Cracker", 75000, 1987, 12, 15);
staff[1] = new Employee("Harry Hacker", 50000, 1989, 10, 1);
staff[2] = new Employee("Tony Tester", 40000, 1990, 3, 15); // raise everyone's salary by 5% 给每人涨5%的工资
for (Employee e : staff) //进行foreach循环
e.raiseSalary(5); // print out information about all Employee objects
for (Employee e : staff)
System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay="
+ e.getHireDay());
}
} class Employee
{
private String name; //实例域定义
private double salary; //实例域定义
private LocalDate hireDay; //实例域定义 public Employee(String n, double s, int year, int month, int day) //构造器的定义
{
name = n;
salary = s;
hireDay = LocalDate.of(year, month, day);
} public String getName() //实例域name的访问器方法
{
return name;
} public double getSalary() //实例域Salary的访问器方法
{
return salary;
} public LocalDate getHireDay() ////实例域HireDay的访问器方法
{
return hireDay;
} public void raiseSalary(double byPercent)
{
double raise = salary * byPercent / 100;
salary += raise;
}

 程序运行结果如下

EmployeeTest.java

 package test

 public class EmployeeTest
{
public static void main(String[] args)
{
// 用三个employee对象填充staff数组
Employee[] staff = new Employee[]; staff[] = new Employee("Carl Cracker", , , , );
staff[] = new Employee("Harry Hacker", , , , );
staff[] = new Employee("Tony Tester", , , , ); // raise everyone's salary by 5% 给每人涨5%的工资
for (Employee e : staff) //进行foreach循环
e.raiseSalary(); // print out information about all Employee objects
for (Employee e : staff)
System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay="
+ e.getHireDay());
}
}

程序运行结果如下:

Employee.java

 import java.time.LocalDate;

 public class Employee {

    private String name;   //实例域定义
private double salary; //实例域定义
private LocalDate hireDay; //实例域定义 public Employee(String n, double s, int year, int month, int day) //构造器的定义
{
name = n;
salary = s;
hireDay = LocalDate.of(year, month, day);
} public String getName() //实例域name的访问器方法
{
return name;
} public double getSalary() //实例域Salary的访问器方法
{
return salary;
} public LocalDate getHireDay() ////实例域HireDay的访问器方法
{
return hireDay;
} public void raiseSalary(double byPercent)
{
double raise = salary * byPercent / ;
salary += raise;
}
}

程序运行结果如下

按以下表头输出学生信息表:

姓名      性别     java成绩

代码如下:

 import java.util.Scanner;

 public class student {
String name;
String sex;
double javascore;
public static void main(String[] args) {
System.out.println("请输入学生人数");
Scanner su = new Scanner(System.in);
int totalStudent = su.nextInt();
student[] stus= new student[totalStudent];
for(int i=;i<totalStudent;i++) {
student s =new student();
stus[i]=s;
System.out.println("请输入第+“i"+"个学生的姓名");
s.name = su.next();
System.out.println("请输入第+“i"+"个学生的性别");
s.sex = su.next();
System.out.println("请输入第+“i"+"个学生的java成绩");
s.javascore = su.nextDouble(); }
printstudent(stus);
su.close();
} public static void printstudent(student[] s) {
System.out.println("姓名\t性别\tjava成绩");
for(int i=;i<s.length;i++) {
System.out.println(s[i].name+"\t"+s[i].sex+"\t"+s[i].javascore);
}
}
}

运行结果如下:

实验2

测试程序2:

l 编辑、编译、调试运行程序4-3(教材116);

l 结合程序运行结果,理解程序代码,掌握静态域(netxtId)与静态方法(getNextId)的用法,在相关代码后添加注释;

理解Java单元(类)测试的技巧。

代码如下:

 /**
* This program demonstrates static methods.
* @version 1.02 2008-04-10
* @author Cay Horstmann
*/
public class StaticTest
{
public static void main(String[] args)
{
// fill the staff array with three Employee objects (用三个employee对象填充staff数组 )
Employee[] staff = new Employee[]; //构造了一个Employee 数组,并填入三个雇员对象 staff[] = new Employee("Tom", );
staff[] = new Employee("Dick", );
staff[] = new Employee("Harry", ); // print out information about all Employee objects (打印有关所有员工对象的信息 )
for (Employee e : staff) //调用getName 方法,getId方法和getSalary方法将每个雇员的信息打印出来
{
e.setId();
System.out.println("name=" + e.getName() + ",id=" + e.getId() + ",salary="
+ e.getSalary());
} int n = Employee.getNextId(); // calls static method (通过类名调用静态方法 )
System.out.println("Next available id=" + n);
}
} class Employee
{
private static int nextId = ; private String name; //实例域定义
private double salary;
private int id; public Employee(String n, double s) //构造器定义
{
name = n;
salary = s;
id = ;
} public String getName() //实例域name的访问器方法
{
return name;
} public double getSalary() //实例域Salary的访问器方法
{
return salary;
} public int getId() //实例域Id的访问方法
{
return id;
} public void setId()
{
id = nextId; // set id to next available id (将id设置为下一个可用id )
nextId++;
} public static int getNextId() //实例域NextId的访问方法
{
return nextId; // returns static field (返回静态字段)
} public static void main(String[] args) // unit test (单元测试 )
{
Employee e = new Employee("Harry", );
System.out.println(e.getName() + " " + e.getSalary());
}
}

运行结果如下:

实验2

测试程序3:

l 编辑、编译、调试运行程序4-4(教材121);

l 结合程序运行结果,理解程序代码,掌握Java方法参数的用法,在相关代码后添加注释;

/**
* This program demonstrates parameter passing in Java.
* @version 1.01 2018-04-10
* @author Cay Horstmann
*/
public class ParamTest
{
public static void main(String[] args)
{
/*
* Test 1: Methods can't modify numeric parameters(方法不能修改数值参数)
*/
System.out.println("Testing tripleValue:");
double percent = ;
System.out.println("Before: percent=" + percent);
tripleValue(percent); //调用方法tripleSalary
System.out.println("After: percent=" + percent); /*
* Test 2: Methods can change the state of object parameters (方法可以更改对象参数的状态)
*/
System.out.println("\nTesting tripleSalary:");
var harry = new Employee("Harry", );
System.out.println("Before: salary=" + harry.getSalary());
tripleSalary(harry); //调用方法tripleSalary
System.out.println("After: salary=" + harry.getSalary()); /*
* Test 3: Methods can't attach new objects to object parameters
*/
System.out.println("\nTesting swap:");
var a = new Employee("Alice", ); //定义一个类型为var的a,并进行初始化
var b = new Employee("Bob", );
System.out.println("Before: a=" + a.getName());
System.out.println("Before: b=" + b.getName());
swap(a, b); //交换函数
System.out.println("After: a=" + a.getName());
System.out.println("After: b=" + b.getName());
} public static void tripleValue(double x) // doesn't work(不工作)
{
x = * x;
System.out.println("End of method: x=" + x);
} public static void tripleSalary(Employee x) // works
{
x.raiseSalary(); //x的调用
System.out.println("End of method: salary=" + x.getSalary());
}
//x和y进行交换
public static void swap(Employee x, Employee y)
{
Employee temp = x;
x = y;
y = temp;
System.out.println("End of method: x=" + x.getName());
System.out.println("End of method: y=" + y.getName());
}
} class Employee // simplified Employee class
{
private String name; //实例域定义
private double salary; public Employee(String n, double s) //构造器定义
{
name = n;
salary = s;
} public String getName() //实例域name的访问器方法
{
return name;
} public double getSalary() ////实例域Salary的访问器方法
{
return salary;
} public void raiseSalary(double byPercent)
{
double raise = salary * byPercent / ;
salary += raise;
}
}

运行结果如下:

实验2

测试程序4:

l 编辑、编译、调试运行程序4-5(教材129);

l 结合程序运行结果,理解程序代码,掌握Java用户自定义类的用法,掌握对象构造方法及对象使用方法,在相关代码后添加注释。

代码如下:

 import java.util.*;

 /**
* This program demonstrates object construction.
* @version 1.02 2018-04-10
* @author Cay Horstmann
*/
public class ConstructorTest
{
public static void main(String[] args)
{
// fill the staff array with three Employee objects (用三个employee对象填充staff数组 )
var staff = new Employee[]; staff[] = new Employee("Harry", );
staff[] = new Employee();
staff[] = new Employee(); // print out information about all Employee objects (打印有关所有员工对象的信息 )
for (Employee e : staff) //foreach循环
System.out.println("name=" + e.getName() + ",id=" + e.getId() + ",salary="
+ e.getSalary());
}
} class Employee
{
private static int nextId; //静态域nextId private int id;
private String name = ""; // instance field initialization(实例字段intialization)
private double salary; // static initialization block (静态intialization块)
static
{
var generator = new Random();
// set nextId to a random number between 0 and 9999 (将nextId设置为0到999之间的随机值)
nextId = generator.nextInt();
} // object initialization block (对象intialization块)
{
id = nextId;
nextId++;
} // three overloaded constructors //三个重载的构造
public Employee(String n, double s)
{
name = n;
salary = s;
} public Employee(double s)
{
// calls the Employee(String, double) constructor
this("Employee #" + nextId, s); //this用来引用当前对象
} // the default constructor //默认的构造器(本应有但没构造,所以系统自动默认了一个构造器
public Employee()
{
// name initialized to ""--see above
// salary not explicitly set--initialized to 0
// id initialized in initialization block
} public String getName() //实例域name的访问器方法
{
return name;
} public double getSalary() //实例域Salary的访问器方法
{
return salary;
} public int getId() //实例域Id的访问器方法
{
return id;
}
}

运行结果如下:

实验2

测试程序5:

l 编辑、编译、调试运行程序4-6、4-7(教材135);

l 结合程序运行结果,理解程序代码,掌握Java包的定义及用法,在相关代码后添加注释;

程序4-6代码如下:

import com.horstmann.corejava.*;
// the Employee class is defined in that package (Employees类在该包中定义) import static java.lang.System.*; //静态导入System类 /**
* This program demonstrates the use of packages.
* @version 1.11 2004-02-19
* @author Cay Horstmann
*/
public class PackageTest
{
public static void main(String[] args)
{
// because of the import statement, we don't have to use
// com.horstmann.corejava.Employee here
var harry = new Employee("Harry Hacker", , , , ); harry.raiseSalary(); // because of the static import statement, we don't have to use System.out here
out.println("name=" + harry.getName() + ",salary=" + harry.getSalary());
}
}

运行结果如下:

程序4-7代码如下:

package com.horstmann.corejava;    //将类放入包中

// the classes in this file are part of this package   (这个文件中的类就是这个包中的一部分)

import java.time.*;   //java.time包的引入

// import statements come after the package statement   (import语句位于package语句之后)

/**
* @version 1.11 2015-05-08
* @author Cay Horstmann
*/
public class Employee
{
private String name; //实例域定义
private double salary;
private LocalDate hireDay; public Employee(String name, double salary, int year, int month, int day) //构造器定义
{
this.name = name; //this用来引用当前对象
this.salary = salary;
hireDay = LocalDate.of(year, month, day);
} public String getName() //实例域name的访问器方法
{
return name;
} public double getSalary() //实例域Salary的访问器方法
{
return salary;
} public LocalDate getHireDay() //实例域HireDay的访问器方法
{
return hireDay;
} public void raiseSalary(double byPercent)
{
double raise = salary * byPercent / ;
salary += raise;
}
}

运行结果如下:

第三部分  实验总结

本周学了第四章,通过这周的学习,我掌握了预定义类的基本使用方法,如Math类、String类、math类、Scanner类、LocalDate类等常用API;大致掌握了用户自定义类的语法规则,如实例域、静态域、构造器方法、更改器方法、访问器方法、静态方法、main方法、方法参数的定义要求等。

  但还是有些不足,概念理解不够深刻,没能够将理论知识掌握好,因此写这博客园写起来挺费劲的,在这花费了很多时间。在运行示例代码的过程中学到了相关知识,但是还没理解透,理解起来有一定的难度,在学习中还有一些漏洞和疑惑,在看翁恺老师的视频时解决了部分,但还是感觉自己有着很多的欠缺,在以后的学习中会更加努力。

201871010123-吴丽丽《面向对象程序设计(Java)》第四周学习总结的更多相关文章

  1. 201871010123-吴丽丽《面向对象程序设计(Java)》第一周学习总结

                                                                            201871010123-吴丽丽<面向对象程序设计 ...

  2. 201871010123-吴丽丽 《面向对象程序设计(Java)》第十六周学习总结

    201871010123-吴丽丽 <面向对象程序设计(Java)>第十六周学习总结 项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ ...

  3. 201871010123-吴丽丽《面向对象程序设计(Java)》第十三周学习总结

    201871010123-吴丽丽<面向对象程序设计(Java)>第十三周学习总结 项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ ...

  4. 201871010123-吴丽丽《面向对象程序设计(Java)》第十二周学习总结

    201871010123-吴丽丽<面向对象程序设计(Java)>第十二周学习总结 项目 内容 这个作业属于哪个课程  https://www.cnblogs.com/nwnu-daizh/ ...

  5. 201871010123-吴丽丽《面向对象程序设计(Java)》第十五周学习总结

    201871010123-吴丽丽<面向对象程序设计(Java)>第十五周学习总结 项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ ...

  6. 201871010123-吴丽丽《面向对象程序设计(Java)》第十一周学习总结

    201871010123-吴丽丽<面向对象程序设计(Java)>第十一周学习总结 项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ ...

  7. 201871010123-吴丽丽 《面向对象程序设计(Java)》第八周学习总结

    201871010123-吴丽丽<面向对象程序设计(Java)>第八周学习总结 项目 内容   这个作业属于哪个课程 http://www.cnblogs.com/nwnu-daizh/  ...

  8. 201871010123-吴丽丽《面向对象程序设计(java)》第二周学习总结

    201871010123-吴丽丽<面向对象程序设计(java)>第二周学习总结                         项目                这个作业属于哪个课程 h ...

  9. 201771010118马昕璐《面向对象程序设计java》第八周学习总结

    第一部分:理论知识学习部分 1.接口 在Java程序设计语言中,接口不是类,而是对类的一组需求描述,由常量和一组抽象方法组成.Java为了克服单继承的缺点,Java使用了接口,一个类可以实现一个或多个 ...

随机推荐

  1. [LeetCode] 727. Minimum Window Subsequence 最小窗口序列

    Given strings S and T, find the minimum (contiguous) substring W of S, so that T is a subsequence of ...

  2. 第01组 Beta冲刺(5/5)

    队名:007 组长博客: https://www.cnblogs.com/Linrrui/p/12031875.html 作业博客: https://edu.cnblogs.com/campus/fz ...

  3. 2018-2019-2 20162329 《网络对抗技术》Exp7: 网络欺诈防范

    目录 Exp7: 网络欺诈防范 一. 基础问题回答 1. 通常在什么场景下容易受到DNS spoof攻击 二. 实验过程 1. 简单应用SET工具建立冒名网站 2. ettercap DNS spoo ...

  4. 外文投稿时应该如何填写有关Social Media的问题?

    外文投稿时应该如何填写有关Social Media的问题? 1 *Please supply our social media editor with a "tweet" or s ...

  5. jenkins 更新插件使用代理

    方法一: 管理插件页面配置如下: 这个 URL 改成http://mirror.xmission.com/jenkins/updates/update-center.json 或https://mir ...

  6. Spring Boot 代码覆盖率测试

    代码覆盖率测试是规范软件开发流程里一个必不可少的环节.一般都是在PG末尾阶段,伴随着IT自测产生. ↑以上,是自己yy出来的啊,反正我司是这样要求的.不跑覆盖率,鬼知道你在代码里夹杂了一些什么东西. ...

  7. Shell脚本——求随机数的最值

    写一个脚本,利用RANDOM生成10个随机数,并找出其中的最大值,和最小值: #!/bin/bash # MAX= MIN= ..};do RAN=$RANDOM [ $i -eq ] &&a ...

  8. centos7 安装docker(手动和脚本安装)换源 卸载

    centos7 安装docker(手动和脚本安装)换源 卸载 Docker 要求 CentOS 系统的内核版本高于 3.10 ,查看本页面的前提条件来验证你的CentOS 版本是否支持 Docker ...

  9. 【前端知识体系-CSS相关】CSS基础知识强化

    1.CSS样式(选择器)的优先级? 1.1 权重的计算规则 第一优先级:无条件优先的属性只需要在属性后面使用!important.它会覆盖页面内任何位置定义的元素样式.(ie6支持上有些bug). 第 ...

  10. 【More Effective C++ 条款1】仔细区别pointers和references

    1)操作符的差别 指针使用"*"和"->"操作符,而引用使用"."操作符 2)初始化的差别 有空指针,但是没有空引用,和const对象 ...