201871010119-帖佼佼《面向对象程序设计（java）》第7周学习总结
博文正文开头格式：（2分）
|
项目 |
内容 |
|
这个作业属于哪个课程 |
https://www.cnblogs.com/nwnu-daizh/ |
|
这个作业的要求在哪里 |
https://www.cnblogs.com/nwnu-daizh/p/11435127.html |
|
作业学习目标 |
|
实验内容和步骤
实验1：在“System.out.println(...);”语句处按注释要求设计代码替换...，观察代码录入中IDE提示，以验证四种权限修饰符的用法。（20分）
实验代码如下：
package ppp;
class Parent {
private String p1 = "这是Parent的私有属性";
public String p2 = "这是Parent的公有属性";
protected String p3 = "这是Parent受保护的属性";
String p4 = "这是Parent的默认属性";
private void pMethod1() {
System.out.println("我是Parent用private修饰符修饰的方法");
}
public void pMethod2() {
System.out.println("我是Parent用public修饰符修饰的方法");
}
protected void pMethod3() {
System.out.println("我是Parent用protected修饰符修饰的方法");
}
void pMethod4() {
System.out.println("我是Parent无修饰符修饰的方法");
}
}
class Son extends Parent{
private String s1 = "这是Son的私有属性";
public String s2 = "这是Son的公有属性";
protected String s3 = "这是Son受保护的属性";
String s4 = "这是Son的默认属性";
public void sMethod1() {
System.out.println(p2);//分别尝试显示Parent类的p1、p2、p3、p4值
System.out.println("我是Son用public修饰符修饰的方法");
}
private void sMethod2() {
System.out.println("我是Son用private修饰符修饰的方法");
}
protected void sMethod() {
System.out.println("我是Son用protected修饰符修饰的方法");
}
void sMethod4() {
System.out.println("我是Son无修饰符修饰的方法");
}
}
public class Demo {
public static void main(String[] args) {
Parent parent=new Parent();
Son son=new Son();
parent.pMethod2(); //分别尝试用parent调用Paren类的方法、用son调用Son类的方法
}
}
Parent的代码如下：
package com.nwnu.demo1;
public class Parent {
private String p1 = "这是Parent的私有属性";
public String p2 = "这是Parent的公有属性";
protected String p3 = "这是Parent受保护的属性";
String p4 = "这是Parent的默认属性";
private void pMethod1() {
System.out.println("我是Parent用private修饰符修饰的方法");
}
public void pMethod2() {
System.out.println("我是Parent用public修饰符修饰的方法");
}
protected void pMethod3() {
System.out.println("我是Parent用protected修饰符修饰的方法");
}
void pMethod4() {
System.out.println("我是Parent无修饰符修饰的方法");
}
}
Son的代码如下：
package com.nwnu.demo2;
import com.nwnu.demo1.Parent;
public class Son extends Parent{
private String s1 = "这是Son的私有属性";
public String s2 = "这是Son的公有属性";
protected String s3 = "这是Son受保护的属性";
String s4 = "这是Son的默认属性";
public void sMethod1() {
System.out.println(p2);//分别尝试显示Parent类的p1、p2、p3、p4值
System.out.println("我是Son用public修饰符修饰的方法");
}
private void sMethod2() {
System.out.println("我是Son用private修饰符修饰的方法");
}
protected void sMethod() {
System.out.println("我是Son用protected修饰符修饰的方法");
}
void sMethod4() {
System.out.println("我是Son无修饰符修饰的方法");
}
}
运行结果如下：
调用p2以及方法2得到的结果：
调用方法得到的结果：
调用方法四得到的结果：
四种权限修饰符的访问范围的情况：
| 访问范围 | private | friendly（默认） | protected | public |
| 同一个类 | 可以访问 | 可以访问 | 可以访问 | 可以访问 |
| 同一个包内的类 | 不可以访问 | 可以访问 | 可以访问 | 可以访问 |
| 不同包内的类 | 不可以访问 | 不可以访问 | 可以访问 |
可以访问 |
| 不同包并且不是子类 | 不可以访问 | 不可以访问 | 不可以访问 | 可以访问 |
protected介于public和private之间，只能被类本身的方法和子类访问，即使子类在不同的包中也可以访问。
默认访问的这种修饰符，只能被在同一个包中的类访问和引用，而不能被其他包中的类使用，即使其他包中有该类的子类。
实验2：测试程序1
l 运行教材程序5-8、5-9、5-10，结合程序运行结果理解程序（教材174页-177页）；
实验代码如下：
package equals; import java.time.*;
import java.util.Objects; 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.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;
} public boolean equals(Object otherObject)
{
// a quick test to see if the objects are identical
if (this == otherObject) return true; //检查这些值是否相等
// must return false if the explicit parameter is null
if (otherObject == null) return false; //如果显示参数为空，则返回false // if the classes don't match, they can't be equal
if (getClass() != otherObject.getClass()) return false; //如果类不相等，则它们不匹配 // now we know otherObject is a non-null Employee
Employee other = (Employee) otherObject; //otherObject 是一个非空雇员对象 // test whether the fields have identical values
return Objects.equals(name, other.name)
&& salary == other.salary && Objects.equals(hireDay, other.hireDay); //检测它们是否具有相同的值
} public int hashCode()
{
return Objects.hash(name, salary, hireDay);
} public String toString()
{
return getClass().getName() + "[name=" + name + ",salary=" + salary + ",hireDay="
+ hireDay + "]";
}
}
package equals; public class Manager extends Employee //子类Manager类继承父类Employee类
{
private double bonus; public Manager(String name, double salary, int year, int month, int day) //Manager构造器
{
super(name, salary, year, month, day);
bonus = 0;
} public double getSalary() //
{
double baseSalary = super.getSalary();
return baseSalary + bonus;
} public void setBonus(double bonus)
{
this.bonus = bonus;
} public boolean equals(Object otherObject)
{
if (!super.equals(otherObject)) return false; //检查是否属于同一个类
Manager other = (Manager) otherObject;
// super.equals checked that this and other belong to the same class
return bonus == other.bonus;
} public int hashCode()
{
return java.util.Objects.hash(super.hashCode(), bonus);
} public String toString()
{
return super.toString() + "[bonus=" + bonus + "]";
}
}
package equals; /**
* This program demonstrates the equals method.
* @version 1.12 2012-01-26
* @author Cay Horstmann
*/
public class EqualsTest
{
public static void main(String[] args)
{
Employee alice1 = new Employee("Alice Adams", 75000, 1987, 12, 15);
Employee alice2 = alice1;
Employee alice3 = new Employee("Alice Adams", 75000, 1987, 12, 15);
Employee bob = new Employee("Bob Brandson", 50000, 1989, 10, 1); System.out.println("alice1 == alice2: " + (alice1 == alice2)); System.out.println("alice1 == alice3: " + (alice1 == alice3)); System.out.println("alice1.equals(alice3): " + alice1.equals(alice3)); System.out.println("alice1.equals(bob): " + alice1.equals(bob)); System.out.println("bob.toString(): " + bob); Manager carl = new Manager("Carl Cracker", 80000, 1987, 12, 15);
Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
boss.setBonus(5000);
System.out.println("boss.toString(): " + boss);
System.out.println("carl.equals(boss): " + carl.equals(boss));
System.out.println("alice1.hashCode(): " + alice1.hashCode());
System.out.println("alice3.hashCode(): " + alice3.hashCode());
System.out.println("bob.hashCode(): " + bob.hashCode());
System.out.println("carl.hashCode(): " + carl.hashCode());
}
}
运行结果如下：
l 删除程序中Employee类、Manager类中的equals()、hasCode()、toString()方法，背录删除方法，在代码录入中理解类中重写Object父类方法的技术要点。（15分）
Employee类重写后代码如下：
package equals; import java.time.*;
import java.util.Objects; 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.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;
} @Override
public int hashCode() { //重写hashCode方法，使相等的两个对象获取的HashCode也相等
// TODO Auto-generated method stub
return Objects.hash(name, salary, hireDay);
} @Override
public boolean equals(Object obj) {
// TODO Auto-generated method stub
if (this == obj) return true; //快速测试几个类的根是否相同，即是否是同一个超类。这个if语句判断两个引用是否是同一个，如果是同一个，那么这两个对象肯定相等。
if (obj == null) return false; //如果显示参数为空，则返回false
if (getClass() !=obj.getClass()) return false; //用getClass（）方法得到对象的类。如果几个类不匹配，则它们不相等 //其他对象是非空Employee类
//在以上判断完成，再将得到的参数对象强制转换为该对象，考虑到父类引用子类的对象的出现，然后再判断对象的属性是否相同
Employee other = (Employee) obj;
//测试字段是否具有相同的值
return Objects.equals(name, other.name) && salary == other.salary && Objects.equals(hireDay, other.hireDay);
} @Override
public String toString() { //把其他类型的数据转为字符串类型的数据（toString方法可以自动生成）
// TODO Auto-generated method stub
return getClass().getName() + "[name=" + name + ",salary=" + salary + ",hireDay=" + hireDay + "]";
} }
Manager类重写之后代码如下：
package equals; public class Manager extends Employee //子类：Manager类继承Employee类
{
private double bonus; //创建私有属性bouns public Manager(String name, double salary, int year, int month, int day)
{
super(name, salary, year, month, day); //子类直接调用超类中已创建的属性
bonus = 0; //给bouns赋初值为空
} public double getSalary()//访问器
{
double baseSalary = super.getSalary();
return baseSalary + bonus;
} public void setBonus(double bonus) //更改器
{
this.bonus = bonus;
} public boolean equals(Object otherObject) //快速测试几个类的根是否相同，即是否是同一个超类
{
if (!super.equals(otherObject)) return false;
Manager other = (Manager) otherObject;
//使用super.equals检查这个类和其他是否属于同一个类
return bonus == other.bonus;
} public int hashCode() //重写hashCode方法，使相等的两个对象获取的HashCode也相等
{
return java.util.Objects.hash(super.hashCode(), bonus);
} public String toString() //把其他类型的数据转为字符串类型的数据（toString方法可以自动生成）
{
return super.toString() + "[bonus=" + bonus + "]";
}
}
EmployeeTest类代码如下：
package equals; /**
* This program demonstrates the equals method.
* @version 1.12 2012-01-26
* @author Cay Horstmann
*/
public class EqualsTest
{
public static void main(String[] args)
{
Employee alice1 = new Employee("Alice Adams", 75000, 1987, 12, 15);
Employee alice2 = alice1;
Employee alice3 = new Employee("Alice Adams", 75000, 1987, 12, 15);
Employee bob = new Employee("Bob Brandson", 50000, 1989, 10, 1); System.out.println("alice1 == alice2: " + (alice1 == alice2)); System.out.println("alice1 == alice3: " + (alice1 == alice3)); System.out.println("alice1.equals(alice3): " + alice1.equals(alice3)); System.out.println("alice1.equals(bob): " + alice1.equals(bob)); System.out.println("bob.toString(): " + bob); Manager carl = new Manager("Carl Cracker", 80000, 1987, 12, 15);
Manager boss = new Manager("Carl Cracker", 80000, 1987, 12, 15);
boss.setBonus(5000);
System.out.println("boss.toString(): " + boss);
System.out.println("carl.equals(boss): " + carl.equals(boss));
System.out.println("alice1.hashCode(): " + alice1.hashCode());
System.out.println("alice3.hashCode(): " + alice3.hashCode());
System.out.println("bob.hashCode(): " + bob.hashCode());
System.out.println("carl.hashCode(): " + carl.hashCode());
}
}
运行结果如下：
1、equals方法：
Object类中的equals方法用于检测某个对象是否同另一个对象相等。它在Object类中的实现是判断两个对象是否相等的引用。如果两个对象具有相同的引用，它们一定是相等的；
如果需要检测两个对象状态的相等性，就需要在新类的定义中需要覆盖equals方法；
定义子类的equals方法时，可调用超累的equals方法；
super. equals (otherObjecct)
2、hashCode方法：
Object类中的哈hashCode方法导出某个对象的散列码。散列码时任意整数，表示dui过的存储地址；
两个相等对象的散列码相等。
3、toString方法：
Object类中的toString方法返回一个代表该类对象域值的字符串；
定义子类的toString方法时，可先调用超类的toString方法；
super.toString()
toString方法是非常重要的调试工具。标准类库中，多数类定义了toString方法，以便用户获得对象状态的必要信息。
实验2：测试程序2
l 在elipse IDE中调试运行程序5-11（教材182页），结合程序运行结果理解程序；
l 掌握ArrayList类的定义及用法；
l 在程序中相关代码处添加新知识的注释；
实验代码如下：
package arrayList; import java.util.*; /**
* This program demonstrates the ArrayList class.
* @version 1.11 2012-01-26
* @author Cay Horstmann
*/
public class ArrayListTest
{
public static void main(String[] args)
{
// fill the staff array list with three Employee objects
ArrayList<Employee> staff = new ArrayList<Employee>(); //用三个Employee对象填充数组 staff.add(new Employee("Carl Cracker", 75000, 1987, 12, 15));
staff.add(new Employee("Harry Hacker", 50000, 1989, 10, 1));
staff.add(new Employee("Tony Tester", 40000, 1990, 3, 15)); // raise everyone's salary by 5%
for (Employee e : staff) //把每个人的薪资提高%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()方法输出所有雇员对象的信息
}
}
package arrayList; import java.time.*; public class Employee
{
private String name; //设置三个私有属性
private double salary;
private LocalDate hireDay; public Employee(String name, double salary, int year, int month, int day) //Employee构造器
{
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;
}
}
运行结构如下：
l 设计适当的代码，测试ArrayList类的set()、get()、remove()、size()等方法的用法。（15分）
实验代码如下：
package arrayList; import java.util.*; /**
* This program demonstrates the ArrayList class.
* @version 1.11 2012-01-26
* @author Cay Horstmann
*/
public class ArrayListTest
{
private static final Employee element = null;
private static final int index = 0; public static void main(String[] args)
{
// fill the staff array list with three Employee objects
ArrayList<Employee> staff = new ArrayList<Employee>(); //用三个Employee对象填充数组 staff.add(new Employee("Carl Cracker", 75000, 1987, 12, 15));
staff.add(new Employee("Harry Hacker", 50000, 1989, 10, 1));
staff.add(new Employee("Tony Tester", 40000, 1990, 3, 15));
ArrayList<Employee> list = new ArrayList<Employee>(); //size()的用法
int size=staff.size();
System.out.println("arrayList中的元素个数是："+size);
for(int i=0;i<staff.size();i++)
{
//get()的用法
Employee e=staff.get(i);
System.out.println("name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay="
+ e.getHireDay());
}
//set()的用法
staff.set(0, new Employee("llx", 20000, 1999, 11, 06));
Employee e=staff.get(0);
System.out.println("修改后的数据为：name=" + e.getName() + ",salary=" + e.getSalary() + ",hireDay="
+ e.getHireDay()); //remove()的用法
staff.remove(2);
System.out.println("将第一个数据删除后：");
int size1=staff.size();
System.out.println("arrayList中的元素个数是："+size1);
for(int i=0;i<staff.size();i++)
{
Employee p=staff.get(i);
System.out.println("name=" + p.getName() + ",salary=" + p.getSalary() + ",hireDay="
+ p.getHireDay());
} // raise everyone's salary by 5%
for (Employee e1 : staff) //把每个人的薪资提高%5
e1.raiseSalary(5); // print out information about all Employee objects
for (Employee e1 : staff) //输出所有雇员对象的信息
System.out.println("name=" + e1.getName() + ",salary=" + e1.getSalary() + ",hireDay="
+ e1.getHireDay()); //利用getName()，getSalary() 和getHireDay()方法输出所有雇员对象的信息
}
}
运行结果如下：
15、泛型数组列表：
Java中，利用ArrayList类，可允许程序在运行时确定数组的大小；
ArrayList是一个采用类型参数的泛型类。为指定数组列表保存元素的对象类型，需要用一对尖括号将数组元素的对象类名括起来加在后面；
没有<>的ArrayList类将被认为是一个删去了类型参数的“原始”类型。
16、数组列表的操作：
ArrayList的定义：ArrayList<T> 对象 = new ArrayList<T>（）；
API：
（1）ArrayList的构造器
——ArrayList<T>()构造一个空数组列表
——ArrayList<T>（int initialCapacity）构造一个具有指定容量的空数组列表；
（2）添加新元素：
API：boolean add（T obj）把元素obj追加到数组列表的结尾；
（3）统计个数：
API：int size（） 返回数组列表中当前元素的个数；
（4）调整大小：
API：void trimToSize（） 把数组列表的存储空间调整到当前的大小；
（5）访问：
API：void Set（int index， T obj） 将obj放入到数组列表index的位置，将覆盖这个位置原来的内容；
API：T get（int index） 将获得指定位置index的元素值；
（6）增加与删除：
API:boolean add（T obj） 向后移动元素，在第n个位置插入obj；
API：T remove（int index） 将第n个位置存放的对象删除，并将后面的元素向前
实验2：测试程序3
l 编辑、编译、调试运行程序5-12（教材189页），结合运行结果理解程序；
l 掌握枚举类的定义及用法；
l 在程序中相关代码处添加新知识的注释；
实验代码如下：
package enums; import java.util.*; /**
* This program demonstrates enumerated types.
* @version 1.0 2004-05-24
* @author Cay Horstmann
*/
public class EnumTest
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in); //首先构造一个Scanner对象，并且与 “标准输入流” System.in关联
System.out.print("Enter a size: (SMALL, MEDIUM, LARGE, EXTRA_LARGE) "); //将该字符串输出在控制台上
String input = in.next().toUpperCase(); //定义一个String类 变量input
Size size = Enum.valueOf(Size.class, input);
System.out.println("size=" + size);
System.out.println("abbreviation=" + size.getAbbreviation());
if (size == Size.EXTRA_LARGE) //判断语句
System.out.println("Good job--you paid attention to the _.");
}
} enum Size
{
SMALL("S"), MEDIUM("M"), LARGE("L"), EXTRA_LARGE("XL"); private Size(String abbreviation) { this.abbreviation = abbreviation; }
public String getAbbreviation() { return abbreviation; } private String abbreviation;
}
运行结果如下：
1、创建枚举类型要使用 Enum 关键字。
2、枚举类对象的属性不应允许被改动, 所以应该使用 private final 修饰。
5、枚举类说明：
1）枚举类是一个类，它的隐含超类是Java.lang.Enum。
2）枚举值并不是整型或其他类型，是被声明的枚举类本身实例；
3）枚举类不能有public 修饰的构造函数，构造函数都是隐含private，编译器自动处理；
4）枚举值隐含都是由public、static、final修饰的，无需自己添加这些修饰符；
5）在比较两个枚举类型的值时，永远不需要调用 equals方法，直接使用“==”进行比较；
实验2：测试程序4
录入以下代码，结合程序运行结果了解方法的可变参数用法（5分）
实验代码如下：
public class TestVarArgus {
public static void dealArray(int... intArray){ //定义为整型，在下面就只能输入整型，不能输入其他的，例如字符串等等
for (int i : intArray)
System.out.print(i +" ");
System.out.println();
}
public static void main(String args[]){
dealArray();
dealArray(1);
dealArray(1, 2, 3);
dealArray(1, 2, 3, 4, 5);
dealArray(1, 2, 3, 4, 5, 6);
}
}
运行结果如下：
定义为字符串类型实验代码如下：
public class TestVarArgus {
public static void dealArray(String... StringArray){ //定义为字符串，在下面就只能输入字符串，不能输入其他的，例如整型等等
for (String string : StringArray)
System.out.print(string +" ");
System.out.println();
}
public static void main(String args[]){
dealArray();
dealArray("Welcome to normal university!");
dealArray("She hates to go my heaven alone!");
dealArray("It will be yours!");
dealArray("Envy!!!!!!!!!!");
}
}
运行结果如下：
实验3：编程练习 参照输出样例补全程序，使程序输出结果与输出样例一致。（ 10分）
实验代码如下：
public class Demo {
public static void main(String[] args) {
Son son = new Son();
son.method();
}
}
class Parent {
Parent() {
System.out.println("Parent's Constructor without parameter");
}
Parent(boolean b) {
System.out.println("Parent's Constructor with a boolean parameter");
}
public void method() {
System.out.println("Parent's method()");
}
}
class Son extends Parent {
//补全本类定义
Son(){
super(false);
System.out.println("Son's Constructor without parameter");
}
public void method() {
System.out.println("Son's method()");
super.method();
}
}
运行结果如下
3. 实验总结：（15分）
在前几周的学习基础上，这周接着学习了第五章，相比国庆节前，加深了对继承类、抽象类以及多态的学习。但对于后面学习的各种方法以及枚举类等新知识，在学习理论知识时，可以跟着老师的思路，觉得已经掌握了知识点，但在实验过程中发现自己还是不会运用，肯平时没有多看书，对基础知识掌握不到位。对于老师设计的简单编程题，由于自己的知识还不够，因此几乎不能独立的做出完整的实验。所以在以后的学习中，我会多看翁恺老师的视频以及老师的课件来学习编程，来写出完整的程序。
201871010119-帖佼佼《面向对象程序设计（java）》第7周学习总结的更多相关文章
- 201771010134杨其菊《面向对象程序设计java》第九周学习总结
第九周学习总结 第一部分:理论知识 异常.断言和调试.日志 1.捕获 ...
- 201871010132-张潇潇《面向对象程序设计(java)》第一周学习总结
面向对象程序设计(Java) 博文正文开头 项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cn ...
- 扎西平措 201571030332《面向对象程序设计 Java 》第一周学习总结
<面向对象程序设计(java)>第一周学习总结 正文开头: 项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 ...
- 杨其菊201771010134《面向对象程序设计Java》第二周学习总结
第三章 Java基本程序设计结构 第一部分:(理论知识部分) 本章主要学习:基本内容:数据类型:变量:运算符:类型转换,字符串,输入输出,控制流程,大数值以及数组. 1.基本概念: 1)标识符:由字母 ...
- 201871010124 王生涛《面向对象程序设计JAVA》第一周学习总结
项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://edu.cnblogs.com/campus/xbsf/ ...
- 201871010115——马北《面向对象程序设计JAVA》第二周学习总结
项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cnblogs.com/nwnu-daizh/p ...
- 201777010217-金云馨《面向对象程序设计(Java)》第二周学习总结
项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cnblogs.com/nwnu-daizh/p ...
- 201871010132——张潇潇《面向对象程序设计JAVA》第二周学习总结
项目 内容 这个作业属于哪个课程 https://www.cnblogs.com/nwnu-daizh/ 这个作业的要求在哪里 https://www.cnblogs.com/nwnu-daizh/p ...
- 201771010123汪慧和《面向对象程序设计Java》第二周学习总结
一.理论知识部分 1.标识符由字母.下划线.美元符号和数字组成, 且第一个符号不能为数字.标识符可用作: 类名.变量名.方法名.数组名.文件名等.第二部分:理论知识学习部分 2.关键字就是Java语言 ...
- 马凯军201771010116《面向对象与程序设计Java》第九周学习总结
一.理论知识部分 异常.日志.断言和调试 1.异常:在程序的执行过程中所发生的异常事件,它中断指令的正常执行. 2.Java的异常处理机制可以控制程序从错误产生的位置转移到能够进行错误处理的位置. 3 ...
随机推荐
- centos 生成网卡UUID
在Linux或CentOS中,可以通过如下命令获取网卡的uuid信息: uuidgen 网卡名07d07031-eb0f-4691-8606-befb46645433 查看网卡UUID nmcli c ...
- 减少HTTP请求的方式
1. 图片地图 缺点:坐标难定义:除了矩形之外几乎无法定义其他形状:通过DHTML(动态DOM操作)创建的图片地图在 IE 不兼容 <img usemap="#map1" b ...
- 理解Redis的反应堆模式
1. Redis的网络模型 Redis基于Reactor模式(反应堆模式)开发了自己的网络模型,形成了一个完备的基于IO复用的事件驱动服务器,但是不由得浮现几个问题: 为什么要使用Reactor模式呢 ...
- Java虚拟机之栈
一.程序计数器(寄存器):PCR 作用:记住下一条JVM指令的执行地址. 特点:①线程私有的 ②不会存在内存溢出 二.虚拟机栈 1.定义 虚拟机栈:线程运行所需要的内存空间. 栈帧:一个栈帧对应一个方 ...
- 初探SpringMVC，走进SpringMVC的世界
1.Springmvc入门 1.1.Springmvc是什么 SpringMVC是Spring中的一个组件,目前(2019)在互联网公司用的很多,是必需学习的一门框架技术!SpringMVC用于web ...
- 几行代码轻松搞定python的sqlite3的存取
很简单: 存数据: 1.加载sqlite3驱动(只需一行代码) 2.用驱动执行查询语句(只需一行代码) 取数据: 1.加载sqlite3驱动(只需一行代码) 2.用驱动执行查询语句(只需一行代码) 乍 ...
- ehcache监控
引入Maven依赖 <dependency> <groupId>org.terracotta.ehcachedx.com.javabi</groupId> < ...
- 折腾笔记-计蒜客T1167AC记
查看原题 原题地址 思路: 判断回文+判断质数 初步代码: #include <bits/stdc++.h> using namespace std; bool prime(int n) ...
- 题解 P3954 【成绩】
题目评级: ★ (水题) 内容及算法: 无,简单模拟计算即可 代码: /** *@author little_frog */ #include <bits/stdc++.h> using ...
- Centos 7.x 内核升级
作者信息 邮箱:sijiayong000@163.com Q Q:601566386 Centos 7.x 内核升级 注意:这篇文章只在 CentOS 7.× 系列版本上验证过,其他 CentOS 版 ...