201871010119-帖佼佼《面向对象程序设计（java）》第四周学习总结
|
项目 |
内容 |
|
这个作业属于哪个课程 |
https://www.cnblogs.com/nwnu-daizh/ |
|
这个作业的要求在哪里 |
https://www.cnblogs.com/nwnu-daizh/p/11435127.html |
|
作业学习目标 |
|
第一部分：总结第四章理论知识（20分）
1、面向对象程序设计概述：面向对象程序设计（OOP）是一种新的程序设计思维，这种方法更接近人类处理现实世界问题的自然表示方法。
（1）对象是面向对象编程的核心，是具体实体，具有明确定义的状态和行为。
（2)对象的三个主要特征：
1）行为:可以对对象施加哪些操作或者可以使用哪些方法；
2）状态：当施加那些操作或者方法时，对象应该如何应对；
3）标识:如何辨别具有相同行为和状态的不同对象。
2、类（class）
（1）类是具有相同属性和行为的一组对象的集合；
（2）类是描述对象的模板，它定义一类对象所拥有的数据和能完成的操作，在面向对象的程序设计中，类是构造程序的基本单位；
（3）每个类由一组结构化的数据（称作实例域）和在其上的一组操作构成。
3、如何识别类：
（1）过程化程序设计，必须从顶部的main函数开始编写程序；
（2）oop的思路，首先从设计类开始，然后在每个类里面添加方法；
（3）识别类简单规则是在问题分析过程中寻找名词，而类的方法则对应动词。
4、类和对象的关系：
（1）类是对象的原型，对象是类的实例，类是同类对象的抽象；
（2）所有属于同一个类的对象都具有相同的特征和操作。
5、类之间的关系：
（1） 依赖：如果一个类中的方法操作了另一个类的对象，那么这个类就依赖于另一个类；
（2）聚合：类A的对象包含类B的对象；
（3）继承：表示一个特定类和一个 一般类之间的关系。
一般来说， 如果类A继承了类B，那么类A 不仅有类B的方法与状态，还有属于自己的 状态与方法。
6、表达类关系的UML符号：
7、预定义类的使用：
（1）已学过的预定义类：Math类、math类、String类、Scanner类；
（2）要使用预定义类的方法，只需知道方法名和参数即可，无需了解它的内在实现过程；
（3）使用预定义类需要在程序开始处用import命令导入该类所在的包路经。
8、对象与对象变量：
（1）在oop中，要想使用对象，就必须首先构造对象，并初始化对象的状态，然后通过对象调用类中的方法；
（2）Java中，用构造器构造并初始化对象；
（3）构造器是类中一个特殊的方法，该方法与类名相同。不需要提供返回值；
（4）构造并初始化对象的格式：
new 构造器名（参数）
9、对象的初始化实例：
（1）Date类，定义在Java标准类库的Java.util包中；
（2）初始化Date类对象的实例：
new Date（）；
System.out.println(new Date())；
（3）可以在类中一个方法用于新创建的对象：String s = new Date（）.toString()；
10、对象变量：
（1）如果要多次使用初始化的变量，可将初始化后的变量放在一个对象变量中；
格式： Date birthday = new Date（）；
（2）对象变量保存对象后，可用对象变量引用对象；
System.out.println(birthday.toString());
（3）可将一个对象变量设置为NULL，表示该对象变量未引用任何对象。
11、更改器方法和访问器方法：
（1）一个类中对实例域进行修改的方法，更改器前面加set；
（2）一个类中对实例域进行访问的方法，前缀get。
12、用户自定义类：
（1）类的定义包括两部分内容：声明和类体
（2）类体由两部分构成：
一为实体域（或成员变量）定义；二为方法定义。
（3）域的定义：
1）实例域：类定义时实例域部分所定义的变量；
2）局部变量：方法体中定义的变量和方法的参数；
3）实例域的隐藏性：局部变量与实例域名字相同时，则实例域被隐藏，即在这个方法内暂时失效。
4）实例域的有效性：在整个类内部有效，而局部变量只在定义它的方法内有效。
5）私有实例域的更改器和访问器：有时需要获得或设置私有实例域的值，此时需提供下面三项内容：
a）一个私有的数据库；
b）一个共有的域访问器方法；
c）一个共有的域访问器方法；
6）final实例域：
可以将实例域定义为final，此类域构建对象时时必须进行初始化；即必须确保在构造器执行之前，这个域的值被设置，并且在后面的操作中，不能再对它的值进行修改，即该域无修改器。
final修饰符多用于基本数据类型域，或不可变类的域；
7）方法定义：
a）包括方法声明和方法体；
b）方法的声明：名字，类型和参数等属性的说明：方法的类型描述的数返回值类型；
c）方法体由局部变量和Java语句构成；一个类中可以有多个方法具有相同的名字，不同的类型，不同的参数，这种情况叫重载；
13、构造器：用来构造并初始化对象。
（1）构造器的名字必须要与它所在类名字相同；
（2）每个包可以由一个以上的构造器；
（3）构造器可以由一个，一个以上的参数；
（4）构造器没有返回值；
（5）构造器总是被new运算符调用；
14、（1）静态域：绝大多数面向对象程序设计语言中，静态域被称为类域。
如果将域定义为static，每个类中只有一个这样的域。而每个对象对于所有的实例域却都有自己的一份拷贝。
（2）main方法：main方法不对任何对象进行操作。静态的main方法将执行并创建程序所需要的对象。
（3）静态常量：静态变量用的少，但是静态常量用的多。
(4).静态方法：用修饰的方法叫静态方法或类方法,静态方法可通过类名或对象来调用,而其他方法只能通过对象来调用。静态方法不能操作对象,不能在静态方法中访问实例域。但静态方法可以访问自身类中的静态域。可以认为静态方法是没有this参数的方法,而在一 个非静态方法中,this参数是表示这个对象/对象构造器的隐式参数。
15、对象的定义：使用一个类创建一个对象时，即创建了一个类的实例域。只有通过对象才可以访问该域的公共实例域，调用类中共有的方法；
16、类的导入：一个类可以直接使用它所在的包中的所有类，也可以使用来自其他包中的所有public类。
（1）静态导入：import语句不仅可以导入类，还增加了静态导入方法和静态域的功能；
（2）将类放如包中：首先用package语句指明报的名字，且该语句应为程序的第一条语句，然后才是定义类的语句；
（3）如果源文件不使用package语句指明包名，源文件的类将属于默认包。
（4）当一个源文件中使用了package语句时，那么这个包中所有的类文件的都必须放在与包名相匹配的目录中；
（5）当程序中所使用的类位于不同包时，起源问价和类文件必须如下组织；
17、包作用域：
（1）类中标记为public的部分可以被任意类使用；
（2）类中标记为private的部分只能在类中使用；
（3）如果没有为类、方法或实例域指定访问控制修饰符public或private，这部分可以被同一包中的所有方法访问；
（4）如果实例域不标记为private，将默认为包可见，这样做会破坏类的封装性。
18、类路径：
（1）类存储在文件系统的子目录中，类得路径必须与包名匹配；
（2）在命令行方式下，设置类路径，使用-classpath选项指定类路径。
第二部分：实验部分
实验名称：实验三 类与对象的定义及使用
1. 实验目的：
(1) 熟悉PTA平台线上测试环境；
(2) 理解用户自定义类的定义；
(3) 掌握对象的声明；
(4) 学会使用构造函数初始化对象；
(5) 使用类属性与方法的使用掌握使用；
(6) 掌握package和import语句的用途。
3. 实验步骤与内容：
实验1 任务1（10分）
package sheji;
import java.util.Scanner;
public class ID {
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println("请输入身份证号18位！");
Scanner in = new Scanner(System.in);
String ID = in.nextLine();
String s1,s2,s3;
int i = 6;
s1 = ID.substring(i, i+4);
s2 = ID.substring(i+4, i+6);
s3 = ID.substring(i+6, i+8);
System.out.println(s1+"-"+s2+"-"+s3);
}
}
运行结果如下：
实验1 任务2（25分）
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Scanner;
public class students {
private static ArrayList<Student> list;
public static void main(String[] args) {
// TODO Auto-generated method stub
list = new ArrayList<>();
Scanner in = new Scanner(System.in);
try {
readFile("studentfile.txt"); //读如文件 studentfile.txt的信息
System.out.println("请选择操作，1按姓名，2按学号，3退出"); //首先在控制台输出 ：请选择操作，1按姓名，2按学号，3退出
int i;
while ((i = in.nextInt()) != 3) //读出并转换下一个表示整型的字符序列
{
switch (i) //switch语句控制菜单
{
case 1: //按学生的姓名查找
System.out.println("请输入姓名"); //在控制台上输出：请输入姓名
String name = in.next(); //定义一个String类对象name，表示下一行字符串
Student student = findStudentByName(name); //通过姓名查找学生的信息
if (student == null) {
System.out.println("没找到"); //if语句判断，如果学生的信息为空，则在控制台输出： 没找到
} else {
System.out.println(student.toString()); //否则，调用toString方法输出学生的信息
}
System.out.println("请选择操作，1按姓名，2按学号，3退出");
break; //退出当前的循环
case 2:
System.out.println("请输入学号"); //按学生的学号查找
String id = in.next(); //定义一个String类对象id，表示下一行字符串
Student student1 = findStudentById(id); //通过学号查找学生的信息
if (student1 == null) { ////if语句判断，如果学生的信息为空，则在控制台输出： 没找到
System.out.println("没找到");
} else {
System.out.println(student1.toString()); //否则，调用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(); //最后关闭0
} } public static void readFile(String path) throws IOException {
FileReader reader = new FileReader(path); //
BufferedReader br = new BufferedReader(reader);
String result; //定义一个String类对象 result
while ((result = br.readLine()) != null) { //while循环
Student student = new Student();
student.setName(result.substring(13));
student.setID(result.substring(0,12)); //从第十三位开始，调用result对象的substring方法得到一个新的字符串
list.add(student);
}
br.close();
} public static Student findStudentByName(String name) { //通过姓名找学生的信息
for (Student student : list) {
if (student.getName().equals(name)) { //用equals方法检测两个字符串是否相等
return student;
}
}
return null; } public static Student findStudentById(String Id) { //通过学号查找学生的信息
for (Student student : list) {
if (student.getID().equals(Id)) { //用equals方法检测两个字符串是否相等
return student;
}
}
return null; }
} class Student {
private String name; //String类对象name的私有的实例域
private String ID; //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 测试程序1（10分）
import java.time.*; /**
* This program tests the Employee class.
* @version 1.13 2018-04-10
* @author Cay Horstmann
*/
public class EmployeeTest //带有public修饰的EmployeeTest类，其包含了main方法
{
public static void main(String[] args)
{
// fill the staff array with three Employee objects
Employee[] staff = new Employee[3]; //构造了一个Employee数组，并填入了三个雇员对象 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%
for (Employee e : staff) //利用Employee类的raiseSalary方法将每个雇员的薪水提高5%
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()); //调用getName方法、getSalary方法以及getHireDay方法将每个雇员的信息打印出来
}
} class Employee //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()
{
return name;
} public double getSalary()
{
return salary;
} public LocalDate getHireDay()
{
return hireDay;
} public void raiseSalary(double byPercent)
{
double raise = salary * byPercent / 100;
salary += raise;
}
}
运行结果如下：
（2）
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 / 100;
salary += raise;
}
}
运行结果如下：
（3）代码如下：
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());
}
}
运行结果如下：
l 参考教材104页EmployeeTest.java，设计StudentTest.java，定义Student类，包含name（姓名）、sex（性别）、javascore（java成绩）三个字段，编写程序，从键盘输入学生人数，输入学生信息，并按以下表头输出学生信息表：
姓名 性别 java成绩
public class StudentTest {
public static void main(String[] args) {
// TODO Auto-generated method stub
Student[] staff = new Student[3]; //构造了一个Employee数组，并填入了三个雇员对象
staff[0] = new Student("lulanxi", "female", 99);
staff[1] = new Student("luhaonan", "male", 98);
staff[2] = new Student("luyuxuan", "male", 97);
for (Student e : staff)
System.out.println("name=" + e.getName() + ",sex=" + e.getSex() + ",javascore="
+ e.getJavascore()); //调用getName方法、getSex方法以及getJavascore法将每个雇员的信息打印出来
}
}
class Student //Employee类
{
private String name; //三个雇员对象的私有实例域
private String sex;
private int javascore;
public Student(String n, String s, int score)
{
name = n;
sex = s;
javascore = score;
}
public String getName()
{
return name;
}
public String getSex()
{
return sex;
}
public int getJavascore()
{
return javascore;
}
}
运行结果如下：
实验2 测试程序2（5分）
/**
* 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 = new Employee[3]; //构造了一个Employee数组，并填入了三个雇员对象 staff[0] = new Employee("Tom", 40000);
staff[1] = new Employee("Dick", 60000);
staff[2] = new Employee("Harry", 65000); // print out information about all Employee objects
for (Employee e : staff)
{
e.setId();
System.out.println("name=" + e.getName() + ",id=" + e.getId() + ",salary="
+ e.getSalary()); ////调用getName方法、getId方法以及getSalary方法将每个雇员的信息打印出来
} int n = Employee.getNextId(); // calls static method 通过类名调用这个方法，只需要访问类的静态域
System.out.println("Next available id=" + n); //将其输出在控制台上
}
} class Employee //Employee类
{
private static int nextId = 1; //静态方法访问自身的静态域 private String name; //私有域
private double salary;
private int id; public Employee(String n, double s)
{
name = n;
salary = s;
id = 0;
} public String getName()
{
return name;
} public double getSalary()
{
return salary;
} public int getId()
{
return id;
} public void setId()
{
id = nextId; // set id to next available id
nextId++;
} public static int getNextId()
{
return nextId; // returns static field
} public static void main(String[] args) // unit test
{
Employee e = new Employee("Harry", 50000);
System.out.println(e.getName() + " " + e.getSalary()); //输出在控制台上
}
}
运行结果如下：
实验2 测试程序3（5分）
/**
* 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 = 10; //采用按值调用，然后再调用以下方法
System.out.println("Before: percent=" + percent);
tripleValue(percent);
System.out.println("After: percent=" + percent); /*
* Test 2: Methods can change the state of object parameters
*/
System.out.println("\nTesting tripleSalary:");
Employee harry = new Employee("Harry", 50000);
System.out.println("Before: salary=" + harry.getSalary());
tripleSalary(harry);
System.out.println("After: salary=" + harry.getSalary()); /*
* Test 3: Methods can't attach new objects to object parameters
*/
System.out.println("\nTesting swap:");
Employee a = new Employee("Alice", 70000); //按引用调用实现交换两个雇员对象状态的方法，但是并没改变存储在a和b中的对象引用
Employee b = new Employee("Bob", 60000);
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 = 3 * x; //假定一个方法，将一个参数的值 增加到三倍，但是percent的值依旧是10
System.out.println("End of method: x=" + x);
} public static void tripleSalary(Employee x)
// works，对象引用作为参数，实现一个雇员的薪水提高两倍的操作，当调用harry = new Employee（。。。）；tripleSalary(harry);实现改变对象参数的方法
{
x.raiseSalary(200);
System.out.println("End of method: salary=" + x.getSalary());
} public static void swap(Employee x, Employee y) //编写交换两个雇员对象状态的方法
{
Employee temp = x; //swap方法的参数x和y被初始化为两个对象引用的拷贝。
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()
{
return name;
} public double getSalary()
{
return salary;
} public void raiseSalary(double byPercent)
{
double raise = salary * byPercent / 100;
salary += raise;
}
}
运行结果如下：
实验2 测试程序4（5分）
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 = new Employee[3]; //构建一个Employee类数组，并定义三个雇员对象 staff[0] = new Employee("Harry", 40000);
staff[1] = new Employee(60000);
staff[2] = new Employee(); // print out information about all Employee objects
for (Employee e : staff)
System.out.println("name=" + e.getName() + ",id=" + e.getId() + ",salary="
+ e.getSalary()); //调用getName方法、getId方法以及getSalary方法将每个雇员的信息打印出来
}
} class Employee //在执行构造器之前，先执行赋值操作，调用方法对域进行初始化，使每个雇员有一个id域
{
private static int nextId; private int id;
private String name = ""; // instance field initialization
private double salary; // static initialization block
static
{
Employee generator = new Random();
// set nextId to a random number between 0 and 9999
nextId = generator.nextInt(10000);
} // object initialization block
{
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);
} // 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()
{
return name;
} public double getSalary()
{
return salary;
} public int getId()
{
return id;
}
}
运行结果如下：
实验2 测试程序5（5分）
实验4.6代码
import com.horstmann.corejava.*; //将类放入一个包中，将包的名字放在源文件的开头，包中定义类的代码之前
// the Employee class is defined in that package import static java.lang.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
Employee harry = new Employee("Harry Hacker", 50000, 1989, 10, 1); // harry.raiseSalary(5); //按值调用 // because of the static import statement, we don't have to use System.out here
out.println("name=" + harry.getName() + ",salary=" + harry.getSalary()); //将其输出在控制台上
}
}
实验4.6运行结果：
实验4.7代码
package com.horstmann.corejava; // the classes in this file are part of this package import java.time.*; // import statements come after the package statement /**
* @version 1.11 2015-05-08
* @author Cay Horstmann
*/
public class Employee //Employee类放置在com.horstmann.corejava包中
{
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.salary = salary;
hireDay = LocalDate.of(year, month, day);
} public String getName()
{
return name;
} public double getSalary()
{
return salary;
} public LocalDate getHireDay()
{
return hireDay;
} public void raiseSalary(double byPercent)
{
double raise = salary * byPercent / 100;
salary += raise;
}
}
运行结果如下：
第三部分：实验总结
通过本周的实验课，以及老师实行的翻转课堂教育，对Java的学习有了更深一步得了解，老师布置的设计题，只能做出来一个，第二个基本思路都不清楚。在课下在助教的视频讲解下，有点进步，这一章主要讲解类与对象，包括面向对象程序设计的概述，使用预定义类，用户自定义类，静态域与静态方法，方法参数，对象构造等内容。Java学习已经进行到第四周，但是在代码的设计上还是没有明显的提升，在课下空余时间，我会尽力解决不会的问题，在代码的设计还是理解方面努力。通过看翁恺老师的视频讲解先把基础的内容很好的掌握。
201871010119-帖佼佼《面向对象程序设计（java）》第四周学习总结的更多相关文章
- 201771010118马昕璐《面向对象程序设计java》第八周学习总结
第一部分:理论知识学习部分 1.接口 在Java程序设计语言中,接口不是类,而是对类的一组需求描述,由常量和一组抽象方法组成.Java为了克服单继承的缺点,Java使用了接口,一个类可以实现一个或多个 ...
- 201771010134杨其菊《面向对象程序设计java》第十周学习总结
第8章泛型程序设计学习总结 第一部分:理论知识 主要内容: 什么是泛型程序设计 泛型类的声明及实例化的方法 泛型方法的定义 ...
- 201771010134杨其菊《面向对象程序设计java》第九周学习总结
第九周学习总结 第一部分:理论知识 异常.断言和调试.日志 1.捕获 ...
- 201771010134杨其菊《面向对象程序设计java》第八周学习总结
第八周学习总结 第一部分:理论知识 一.接口.lambda和内部类: Comparator与comparable接口: 1.comparable接口的方法是compareTo,只有一个参数:comp ...
- 201571030332 扎西平措 《面向对象程序设计Java》第八周学习总结
<面向对象程序设计Java>第八周学习总结 项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https: ...
- 20145213《Java程序设计》第四周学习总结
20145213<Java程序设计>第四周学习总结 教材学习内容总结 本周任务是学习面向对象的继承.接口以及之后的如何活用多态.(还真是路漫漫其修远兮啊!)教材也是延续上周艰深晦涩的语言风 ...
- 《Java程序设计》第四周学习总结
20145224-陈颢文 <Java程序设计>第四周学习总结 教材学习内容总结 第六章 继承与多态 ·继承就是面向对象中,子类继承父类,避免重复的行为定义.重复再程序设计上是非常不好的信号 ...
- 20155304 2016-2017-2 《Java程序设计》第四周学习总结
20155304 2016-2017-2 <Java程序设计>第四周学习总结 教材学习内容总结 第六章 继承: 概念: 面向对象中,为避免多个类间重复定义共同行为.(简单说就是将相同的程序 ...
- 201521123038 《Java程序设计》 第四周学习总结
201521123038 <Java程序设计> 第四周学习总结 1. 本周学习总结 1.1 尝试使用思维导图总结有关继承的知识点. 1.2 使用常规方法总结其他上课内容. 1.通过 ins ...
- 201521123061 《Java程序设计》第四周学习总结
201521123061 <Java程序设计>第四周学习总结 1. 本章学习总结 (1)思维导图: --- (2)上课内容总结: 第四周学习了Java中的继承与多态,思维导图中已经给出了本 ...
随机推荐
- zabbix4.0开源监控部署
---恢复内容开始--- 1.安装依赖环境 yum -y install telnet net-tools python-paramiko dejavu-sans-fonts python-setup ...
- opencv 5 图像转换（3 重映射 仿射变换 直方图均衡化）
重映射 实现重映射(remap函数) 基础示例程序:基本重映射 //---------------------------------[头文件.命名空间包含部分]------------------- ...
- Docker从入门到掉坑(三)：容器太多，操作好麻烦
前边的两篇文章里面,我们讲解了基于docker来部署基础的SpringBoot容器,如果阅读本文之前没有相关基础的话,可以回看之前的教程. Docker 从入门到掉坑 Docker从入门到掉坑(二): ...
- Web Deploy远程发布
前言 我们在使用VS开发.net网站的时候,部署时可能会遇到缺少dll的问题,每次都远程桌面登陆,然后拷贝过去,太麻烦了.我们可以使用Web Deploy这个远程部署工具,不仅部署容易了,也方便进行迭 ...
- ProxySQL读写分离代理
实现ProxySQL反向代理Mysql读写分离 简介 ProxySQL相当于小型的数据库,在磁盘上有存放数据库的目录:ProxySQL用法和mysql相似 启动ProxySQL后会有两个监听端口: 6 ...
- [Odoo12基础教程]之第一篇-创建Todo应用
声明: 本教程基于 Ruter 老师的 [Odoo基础教程系列] ,Ruter老师教程的链接地址为:Odoo基础教程系列 . 至于为什么已经有了Ruter老师的教程,还要自己再搬移一份呢?是基于一 ...
- 【Luogu P1981】表达式求值
点我进入原题Luogu P1981 [解题思路] 仔细分析题目,这就是一道模拟题…… 直接按照符号读入全部的数字,先算乘法,最后把全部数加起来就是结果了 记得要%10000取最后四位 [参考程序] # ...
- Scala学习系列一
一 scala介绍 Scala是一门以java虚拟机(JVM)为目标运行环境并将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言. 1) Scala 是一门多范式 (multi-parad ...
- 在Spring Security框架下JWT的实现细节原理
一.回顾JWT的授权及鉴权流程 在笔者的上一篇文章中,已经为大家介绍了JWT以及其结构及使用方法.其授权与鉴权流程浓缩为以下两句话 授权:使用可信用户信息(用户名密码.短信登录)换取带有签名的JWT令 ...
- 《手把手教你》系列练习篇之7-python+ selenium自动化测试 -压轴篇（详细教程）
1. 简介 “压轴”原本是戏曲名词,指一场折子戏演出的倒数第二个剧目.在现代社会中有很多应用,比如“压轴戏”,但压轴也是人们知识的一个盲区.“压轴”本意是指倒数第二个节目,而不是人们常说的倒数第一个, ...