# 框架
框架是一系列已经完成的代码的集合,用于解决特定的问题。
框架表现为某些`.jar`包文件,在开发时,需要在开发环境中导入这些`.jar`文件,然后按照框架约定的语法和工作流程来编程。
每种框架都是为了解决某个特定的问题而存在的。
# Spring框架
2 通过eclipse生成`web.xml`文件
3 添加`Spring`依赖:打开网页`maven.tedu.cn`(如果连接的不是公司的网络,换成`maven.aliyun.com`),搜索`spring-webmvc`,并在结果中找到`Group`为`org.springframework`,且`Artifact`为`spring-webmvc`的项,并选择版本,然后将配置代码粘贴到项目的`pom.xml`中(事先在`pom.xml`中自行添加`<dependencies>`节点):
<!-- 配置依赖 -->
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>3.2.8.RELEASE</version>
</dependency>
</dependencies>
4 从FTP服务器下载`applicationContext.zip`并解压,得到`applicationContext.xml`,复制并粘贴到项目中的`src\main\resources`文件夹中。
5 在`applicationContext.xml`中添加配置:
<!-- id:自定义名称,用于获取对象 -->
<!-- class:需要Spring来创建哪个类的对象 -->
<bean
id="date"
class="java.util.Date" />
6 编写代码,获取对象,测试运行:
public static void main(String[] args) {
// 确定配置文件的文件名
String fileName
= "applicationContext.xml";
// 加载配置文件,获取Spring容器
ApplicationContext ac
= new ClassPathXmlApplicationContext(
fileName);
// 从Spring容器中获取对象
// getBean()方法的参数是配置文件中的bean id
Date date = (Date) ac.getBean("date");
// 测试
System.out.println(date);
}
# 通过Spring获取对象
## 1 【重要】 类本身存在无参数的构造方法
以`Date`为例,这个类存在无参数的构造方法,所以,可以使用这样的配置:
<bean
id="date"
class="java.util.Date" />
## 2 【了解】 类自身存在静态的工厂方法
以`Calendar`为例,在这个类中,存在`getInstance()`方法可以获取`Calendar`对象,并且,这个方法还是`static`的!
public abstract class Calendar {
public static Calendar getInstance() {
// ...
}
}
则配置:
<!-- factory-method:工厂方法的方法名称 -->
<bean
id="calendar"
class="java.util.Calendar"
factory-method="getInstance" />
## 3 【了解】 其它类中有工厂方法
类自身不便于创建对象,而是通过其它类中的工厂方法(非静态)来创建对象的!
public interface IUserDao {
}
public class UserDaoImpl implements IUserDao {
}
public class UserDaoFactory {
public IUserDao getInstance() {
return new UserDaoImpl();
}
}
配置:
<!-- 先配置工厂类 -->
<!-- 再配置需要获取对象的类 -->
<!-- factory-bean:工厂类的bean id -->
<bean
id="userDaoFactory"
class="cn.tedu.spring.UserDaoFactory" />
<bean
id="userDaoImpl"
class="cn.tedu.spring.UserDaoImpl"
factory-bean="userDaoFactory"
factory-method="getInstance" />
# 关于Maven下载的jar包失败的解决方案
1 在eclipse中点击`Window`菜单中的`Preferences`菜单项,选择`Maven`分支下的`User Settings`,右侧显示的最后一项就是Maven本地存储路径,记住这个位置,在机房的学生机中,都在桌面的`home`的`.m2`中
2 关闭eclipse
3 找到本地存储路径,删除`.m2`文件夹,在Linux系统下,这个文件夹是隐藏的,请先设置为显示隐藏项目
4 打开eclipse
5 如果问题仍然存在,对项目点鼠标右键,依次选择`Maven` -> `Update Project`,并在弹出的对话框中勾选`Force Update ...`
# 关于Resource leak
leak表示内存泄漏甚至内存溢出!
当尝试释放某个对象所占用的资源,却无法释放时,就会导致内存泄漏!例如使用某个流之后,没有调用`close()`方法!这样,会导致某个对象一直存在于内存中,已经不再使用,而JVM却认为这个对象是有用的,一直不销毁它!就会导致这个对象无谓的占用内存!
所以,其实少量的内存泄漏是没有明显的危害的!
内存泄漏的终级表现就是内存溢出!
对于开发者而言,应该避免任何可能的内存泄漏,常规做法就是那些需要释放资源的对象,在使用完毕之后,及时释放,例如调用流的`close()`方法。
# 请描述“封装”这个概念
封装是“装”了再“封”的过程。
很多时候,也许需要传递或克隆多个数据,但是,为了易于处理,会把这些数据“装”起来:
public class User {
public String name;
public int age;
}
但是,仅仅只是装起来,可能会有问题:
User user = new User();
user.age = 9527;
以上代码就表现出“合法却不合理”的现象!为了避免类的属性被随便访问,可以:
public class User {
private String name;
private int age;
}
使用更加“严格”的权限,就是将属性“封”起来了!
经过以上调整,类似`user.age = 9527;`的语法将不成立!当然,私有化的目的不是不允许使用,而是不允许随意使用,所以,还应该添加其它的访问方式:
public class User {
private String name;
private int age;
public void setAge(int age) {
this.age = age;
}
}
则访问方式就会变为:
User user = new User();
user.setAge(9527);
由于数据的访问会经过方法,而方法中是可以添加其它的判断逻辑的:
public class User {
private String name;
private int age;
public void setAge(int age) {
if (age >= 18 && age <= 50) {
this.age = age;
}
}
}
为了便于获取这个属性的值,还应该添加匹配的`get`方法:
public class User {
private String name;
private int age;
public void setAge(int age) {
if (age >= 18 && age <= 50) {
this.age = age;
}
}
public int getAge() {
return age;
}
}
以上代码,表现的是对类的属性进行封装,其实,工厂模式也是对类本身进行封装的表现!例如:
public cn.tedu.dao.IUserDao
[默认] cn.tedu.dao.UserDao
public cn.tedu.dao.UserDaoFactory
# 请问抽象类和接口的区别
这是2个不同的概念,一个是class,一个是interface。
语法区别:接口中所有的成员都是public的,属性都是static final的,方法都是abstract的,而抽象类中的成员的访问权限是没有约束的,属性也不一定是static final的,方法也可以是普通的方法;类与抽象类的关系是一对一的继承(extends)的关系,类与接口的关系是一对多的实现(implements)的关系;接口也继承(extends)接口,并且可以一继承多。
抽象类的本质是一个类,类,表示“类别”,接口表示的是“标准、行为模式、行为能力”。
类与抽象类是"子类 is a 抽象类"的关系,类与接口是"类 has 接口"的关系。
public class Person {}
public class Teacher extends Person {}
public class Student extends Person {}
public class Driver extends Person {}
public class Person implements 教, 学, 驾驶, 烹饪 {
private boolean 能否教书;
private boolean 能否烹饪;
}
public interface 教 {}
public interface 学 {}
public interface 驾驶 {}
public interface 烹饪 {}
# 关于static
`static`关键字用于修饰类的成员。
public class Person {
public static String name;
public static void run() {
}
public static class InnerClass {
}
public static interface InnerInterface {
}
}
`static`的特性:唯一,常驻。
被`static`修饰的成员会加载到内存中的静态域中,无论创建多少个这个类的对象,`static`成员都只会有1个!所以,通常也说静态成员是独立的,从语法上表现为例如`Person.name`这个方式来访问。
被`static`修饰的成员将最优先加载到内存中,并且不会被销毁,仅当显式的销毁对象或程序运行结束,该对象才会消失!
框架是一系列已经完成的代码的集合,用于解决特定的问题。
框架表现为某些`.jar`包文件,在开发时,需要在开发环境中导入这些`.jar`文件,然后按照框架约定的语法和工作流程来编程。
每种框架都是为了解决某个特定的问题而存在的。
# Spring框架
## 作用
当在项目中需要某个对象时,不必再使用`new`关键字创建对象,而是通过**Spring容器**获取对象。
## 使用
1 创建`Maven Project`,在弹出的对话框中勾选`Create a simple……`,然后在下一个界面中填写`Group Id`、`Artifact Id`,并将`Packaging`选为`war`即可。2 通过eclipse生成`web.xml`文件
3 添加`Spring`依赖:打开网页`maven.tedu.cn`(如果连接的不是公司的网络,换成`maven.aliyun.com`),搜索`spring-webmvc`,并在结果中找到`Group`为`org.springframework`,且`Artifact`为`spring-webmvc`的项,并选择版本,然后将配置代码粘贴到项目的`pom.xml`中(事先在`pom.xml`中自行添加`<dependencies>`节点):
<!-- 配置依赖 -->
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>3.2.8.RELEASE</version>
</dependency>
</dependencies>
4 从FTP服务器下载`applicationContext.zip`并解压,得到`applicationContext.xml`,复制并粘贴到项目中的`src\main\resources`文件夹中。
5 在`applicationContext.xml`中添加配置:
<!-- id:自定义名称,用于获取对象 -->
<!-- class:需要Spring来创建哪个类的对象 -->
<bean
id="date"
class="java.util.Date" />
6 编写代码,获取对象,测试运行:
public static void main(String[] args) {
// 确定配置文件的文件名
String fileName
= "applicationContext.xml";
// 加载配置文件,获取Spring容器
ApplicationContext ac
= new ClassPathXmlApplicationContext(
fileName);
// 从Spring容器中获取对象
// getBean()方法的参数是配置文件中的bean id
Date date = (Date) ac.getBean("date");
// 测试
System.out.println(date);
}
# 通过Spring获取对象
## 1 【重要】 类本身存在无参数的构造方法
以`Date`为例,这个类存在无参数的构造方法,所以,可以使用这样的配置:
<bean
id="date"
class="java.util.Date" />
## 2 【了解】 类自身存在静态的工厂方法
以`Calendar`为例,在这个类中,存在`getInstance()`方法可以获取`Calendar`对象,并且,这个方法还是`static`的!
public abstract class Calendar {
public static Calendar getInstance() {
// ...
}
}
则配置:
<!-- factory-method:工厂方法的方法名称 -->
<bean
id="calendar"
class="java.util.Calendar"
factory-method="getInstance" />
## 3 【了解】 其它类中有工厂方法
类自身不便于创建对象,而是通过其它类中的工厂方法(非静态)来创建对象的!
public interface IUserDao {
}
public class UserDaoImpl implements IUserDao {
}
public class UserDaoFactory {
public IUserDao getInstance() {
return new UserDaoImpl();
}
}
配置:
<!-- 先配置工厂类 -->
<!-- 再配置需要获取对象的类 -->
<!-- factory-bean:工厂类的bean id -->
<bean
id="userDaoFactory"
class="cn.tedu.spring.UserDaoFactory" />
<bean
id="userDaoImpl"
class="cn.tedu.spring.UserDaoImpl"
factory-bean="userDaoFactory"
factory-method="getInstance" />
# 关于Maven下载的jar包失败的解决方案
1 在eclipse中点击`Window`菜单中的`Preferences`菜单项,选择`Maven`分支下的`User Settings`,右侧显示的最后一项就是Maven本地存储路径,记住这个位置,在机房的学生机中,都在桌面的`home`的`.m2`中
2 关闭eclipse
3 找到本地存储路径,删除`.m2`文件夹,在Linux系统下,这个文件夹是隐藏的,请先设置为显示隐藏项目
4 打开eclipse
5 如果问题仍然存在,对项目点鼠标右键,依次选择`Maven` -> `Update Project`,并在弹出的对话框中勾选`Force Update ...`
# 关于Resource leak
leak表示内存泄漏甚至内存溢出!
当尝试释放某个对象所占用的资源,却无法释放时,就会导致内存泄漏!例如使用某个流之后,没有调用`close()`方法!这样,会导致某个对象一直存在于内存中,已经不再使用,而JVM却认为这个对象是有用的,一直不销毁它!就会导致这个对象无谓的占用内存!
所以,其实少量的内存泄漏是没有明显的危害的!
内存泄漏的终级表现就是内存溢出!
对于开发者而言,应该避免任何可能的内存泄漏,常规做法就是那些需要释放资源的对象,在使用完毕之后,及时释放,例如调用流的`close()`方法。
# 请描述“封装”这个概念
封装是“装”了再“封”的过程。
很多时候,也许需要传递或克隆多个数据,但是,为了易于处理,会把这些数据“装”起来:
public class User {
public String name;
public int age;
}
但是,仅仅只是装起来,可能会有问题:
User user = new User();
user.age = 9527;
以上代码就表现出“合法却不合理”的现象!为了避免类的属性被随便访问,可以:
public class User {
private String name;
private int age;
}
使用更加“严格”的权限,就是将属性“封”起来了!
经过以上调整,类似`user.age = 9527;`的语法将不成立!当然,私有化的目的不是不允许使用,而是不允许随意使用,所以,还应该添加其它的访问方式:
public class User {
private String name;
private int age;
public void setAge(int age) {
this.age = age;
}
}
则访问方式就会变为:
User user = new User();
user.setAge(9527);
由于数据的访问会经过方法,而方法中是可以添加其它的判断逻辑的:
public class User {
private String name;
private int age;
public void setAge(int age) {
if (age >= 18 && age <= 50) {
this.age = age;
}
}
}
为了便于获取这个属性的值,还应该添加匹配的`get`方法:
public class User {
private String name;
private int age;
public void setAge(int age) {
if (age >= 18 && age <= 50) {
this.age = age;
}
}
public int getAge() {
return age;
}
}
以上代码,表现的是对类的属性进行封装,其实,工厂模式也是对类本身进行封装的表现!例如:
public cn.tedu.dao.IUserDao
[默认] cn.tedu.dao.UserDao
public cn.tedu.dao.UserDaoFactory
# 请问抽象类和接口的区别
这是2个不同的概念,一个是class,一个是interface。
语法区别:接口中所有的成员都是public的,属性都是static final的,方法都是abstract的,而抽象类中的成员的访问权限是没有约束的,属性也不一定是static final的,方法也可以是普通的方法;类与抽象类的关系是一对一的继承(extends)的关系,类与接口的关系是一对多的实现(implements)的关系;接口也继承(extends)接口,并且可以一继承多。
抽象类的本质是一个类,类,表示“类别”,接口表示的是“标准、行为模式、行为能力”。
类与抽象类是"子类 is a 抽象类"的关系,类与接口是"类 has 接口"的关系。
public class Person {}
public class Teacher extends Person {}
public class Student extends Person {}
public class Driver extends Person {}
public class Person implements 教, 学, 驾驶, 烹饪 {
private boolean 能否教书;
private boolean 能否烹饪;
}
public interface 教 {}
public interface 学 {}
public interface 驾驶 {}
public interface 烹饪 {}
# 关于static
`static`关键字用于修饰类的成员。
public class Person {
public static String name;
public static void run() {
}
public static class InnerClass {
}
public static interface InnerInterface {
}
}
`static`的特性:唯一,常驻。
被`static`修饰的成员会加载到内存中的静态域中,无论创建多少个这个类的对象,`static`成员都只会有1个!所以,通常也说静态成员是独立的,从语法上表现为例如`Person.name`这个方式来访问。
被`static`修饰的成员将最优先加载到内存中,并且不会被销毁,仅当显式的销毁对象或程序运行结束,该对象才会消失!