Task1第六天（2017年5月20日）

今日计划

出现了知识困难，学习一下JAVA基础知识

一、面向对象

特征：封装，继承，多态、

开发：其实就是找对象使用，没有对象，就创建一个对象。

找对象，建立对象，使用对象，维护对象的关系。

类与对象的关系：

现实生活中的对象：张三 李四

想要描述：提取对象中共性内容，对具体的抽象。

描述时：这些对象的共性有：姓名，年龄，性别，学习Java的功能。

映射到java中，描述就是class定义的类

具体对象就是对应java在堆内存中用new建立的实体。

类：对现实生活中事物的描述。

对象：就是这类事物实实在在存在的个体。

需求：描述汽车（颜色，轮胎数）。描述事物其实就是描述事物的属性和行为。

属性对应是类中变量，行为对应的类中的函数（方法）

其实定义类，就是在描述事物，就是在定义属性和行为，属性和行为共同成为类中的成员（成员变量和成员方法）。

/*

 * 成员变量和局部变量。

 * 作用范围。

 * 成员变量作用于整个类中。

 * 局部变量作用于函数中，或者语句中。

 * 在内存中的位置：

 * 成员变量：堆内存，因为对象存在，才在内存中存在

 * 局部变量：栈内存

 * */

class Car

{

//描述颜色

String color = "red";

//描述轮胎数

int num = 4;

//运行行为。

void run()

{

System.out.println(color+".."+num);

}

}

class CarDemo

{

public static void main(String[] args)

{

//生产汽车。在java中通过new操作符来完成。

//其实就是在堆内存产生一个实体。

Car c = new Car();//c就是一个类类型变量。记住：类类型变量指向对象

//需求：将已有的车改成蓝色。指挥该对象做使用。在java指挥方式是：对象。对象成员

c.color = "blue";

c.run();

Car c1 = new Car();

c1.run();

}

}

匿名对象： new Car().num = 5;

new Car().color = "blue"; 

匿名对象使用方式一： 党对对象的方法只调用一次时可以用匿名对象来完成，这样写比较简洁。

如果对一个对象进行多个成员调用，必须给这个对象起个名字

匿名对象使用方式二：可以将匿名对象作为实际参数进行传递。

封装（Encapsulation）

指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

好处：

将变化隔离

便于使用

提高重用性

提高安全性

封装原则：

将不需要对外提供的呢绒都隐藏起来

把属性都隐藏，提供公共方法对其访问

Private：私有，权限修饰符：用于修饰类中的成员（成员变量，成员函数）

私有只在本类中有效。

私有化以后，类以外即使建立对象也不能直接访问。

就需要在类中提供对应访问方式

注意：私有仅仅是封装的一种表现形式

之所以对外提供访问方式，就因为可以在访问方式中加入逻辑判断等语句

对方问的数据进行操作，提高代码的健壮性。

构造函数：

1、对象已建立就会调用与之对应的构造函数

2、构造函数的作用：可以用于给对象进行初始化

3、当一个类中没有定义构造函数时，那么系统会默认给该类加一个空参数的构造函数

构造函数与一般函数区别：

 1、构造函数与一般函数在写法上不同

 2、在运行上也有不同：

 * 构造函数在对象一建立时就运行，给对象初始化

 * 而一般函数是对象调用才执行，是给对象添加对象具备的功能

 * 一个对象建立构造函数只运行一次

 * 而一般方法可以被改对象调用多次。

构造代码块

作用：给对象进行初始化

对象一建立就运行，而且优先于构造函数

构造代码块与构造函数区别

构造代码块是给所有对象进行统一初始化

而构造函数是给对应的对象初始化。

（ 构造代码块中定义的是不同对象共性的初始化内容）

this关键字

this 代表它所在函数所属对象的引用 

 简单说：哪个对象在调用this所在的函数，this就代表哪个对象

this功能：

1、当定义类中功能时，该函数内部要用到调用该函数的对象是，这时候用this来表示对象。但凡本类功能内部使用到了本类对象，都用this表示。

2、用于构造函数之间调用

注意：this只能定义在构造函数的第一行，因为初始化要先执行。

Static关键字

静态：static

用法：是一个修饰符，用于修饰成员（成员变量，成员函数）

static特点：

1、随着类的加载而加载

   也就是说随着类的小时而消失。说明它的生命周期最长

2、优先于对象存在

3、被所有对象所共享

4、可以直接被类名所调用

实例变量与类变量区别

1、存放位置。

  类变量随着类的加载而存在于方法区中。

实例变量随着对象的建立而存在于堆内存中

2、生命周期

类变量生命周期最长，随着类的消失而消失。

实例变量生命周期随着对象的消失而消失。

静态使用注意事项：

 1、 静态方法只能访问静态成员。

  非静态方法既可以访问静态也可以访问非静态。

 2、静态方法中不可以定义this，super关键字。

   因为静态优先于对象存在，所以静态方法中不能出现this。

 静态有利有弊

 利处：对对象的共享数据进行单独空间的存储，节省空间。没有必要每一个对象都存储一份。

  可以直接被类名调用。

 弊端：生命周期过长。

  访问出现局限性。（静态虽好，只能访问静态）

主函数：是一个特殊的函数。作为程序的入口，可以被jvm调用

主函数的定义：public static void main(String[] args)

public:代表该函数的访问权限是最大的

static：代表主函数随着类的加载就已经存在了。

void：主函数没有具体的返回值

Main:不是关键字，但是是一个特殊的单词，可以被jvm识别。

(String[] args):函数的参数,参数类型是一个数组，该数组中的元素是字符串。字符串类型的数组。

主函数是固定格式的：jvm识别。

jvm 在调用主函数时，传入的是new String[0];

public class MainDemo {

public static void main(String[] args)// new String[]

{

String[] arr = {"哈哈","呵呵","嘿嘿","嘻嘻","hiahia"};

MainTest.main(arr);

}

}

class MainTest

{

public static void main(String[] args)// new String[]

{

for (int i = 0; i < args.length; i++) {

System.out.println(args[i]);

}

}

}

  什么时候使用静态？

  要从两方面下手：

 因为静态修饰的内容有成员变量和函数。

 什么时候定义静态变量（类变量）呢？

 当对象中出现共享数据时，该数据被静态所修饰。

 对象中的特有数据要定义成非静态存在于堆内存中.

 什么时候定义静态函数呢？

当功能内部没有访问到非静态数据（对象的特有数据）

那么该功能可以定义成静态的。

静态应用-工具类

 虽然可以通过建立ArrayTool的对象使用这些工具方法，对数组进行操作。

 发现了问题“

 1、对象适用于封装数据的，可是ArrayTool对象并未封装特有数据

 2、操作数组的每一个方法都没有用到ArrayTool对象中的特有数据

 这是就考虑，让程序更眼镜，是不需要对象的。

 可以将ArrayTool中的方法都定义成static 。直接通过类名调用即可

 将方法都静态后，可以方便与使用，但该类还是可以被其他程序建立对象。

 为了更为严谨，强制要求该类不能建立对象。

 可以通过将构造函数私有化完成。

ArryTool.java

/**

 * 这是一个可以对数组操作的工具类，该类中提供了一下功能：

 * 1、获取最值

 * 2、排序

 * 3、输出数组功能

 * @author 小明

 * @version V1.1

 * */

public class ArrayTool {

/**

 * 空参数构造函数

 */

private ArrayTool(){

}

/**

 * 获取一个整型数组中的最小值。

 * @param arr 接收一个int类型的数组

 * @return 会返回一个数组中的最小值

 */

public static int getMin(int[] arr)//查找数组最小值

{

int min = 0 ;

for (int i = 0; i < arr.length; i++) {

if (arr[i]<arr[min]) {

min = i;

}

}

return arr[min];

}

/**

 * 获取一个整型数组中的最大值

 * @param arr 接收一个int类型的数组

 * @return 会返回一个数组中的最大值

 */

public static int getMax(int[] arr)//查找数组最大值

{

int max = 0;

for (int i = 0; i < arr.length; i++) {

if (arr[i]>arr[max]) {

max = i;

}

}

return arr[max];

}

/**

 * 给int数组进行选择排序

 * @param arr 接收一个int类型的数组

 */

public static void selectSort(int[] arr)//数据排序，从小到大

{

for (int x = 0; x < arr.length-1; x++)

{for (int y = x+1;  y< arr.length; y++)

{if (arr[x]>arr[y])

swap(arr,x,y); }}  

}

/**

 * 给int数组进行冒泡排排序

 * @param arr 接收一个int类型的数组

 */

public static void bubbleSort(int[] arr)//数据排序从小到大 冒泡法

{

for (int x = 0; x < arr.length-1; x++)

for (int y = 0; y < arr.length-x-1; y++)

if(arr[y]>arr[y+1])

swap2(arr,y,y+1);

}

/**

 * 给数组中的袁术进行位置置换

 * @param arr 接收一个int类型的数组

 * @param a 要置换的位置

 * @param b 要置换的位置

 */

private static void swap(int[] arr,int a,int b)//交换数组元素位置，引入第三方变量

{

int temp = arr[a];

arr[a] = arr[b];

arr[b] = temp;

}

/**

 * 给数组中的袁术进行位置置换（不引入第三方变量）

 * @param arr 接收一个int类型的数组

 * @param a 要置换的位置

 * @param b 要置换的位置

 */

private static void swap2(int[] arr,int a,int b)//交换数组元素位置，不引入第三方变量

{

arr[a]=arr[a]^arr[b];

arr[b]=arr[a]^arr[b];

arr[a]=arr[b]^arr[a];

}

/**

 * 用于打印数组中的元素，打印形式是：[elemet1,element2,……]

 * @param arr 接收一个int类型的数组

 */

public static void printArray(int[] arr)//输出数组元素并加上[]

{

System.out.print("[");

for (int x = 0; x < arr.length; x++) {

if(x!=arr.length-1)

System.out.print(arr[x]+",");

else 

System.out.println(arr[x]+"}");

}

}

}

ArrayToolDemo.java

package six;

import six.ArrayTool;//进口ArrayTool类

public class ArrayToolDemo {

public static void main(String[] args) {

int[] arr = {3,1,87,32,8};

int max = ArrayTool.getMax(arr);//获取arr中最大值

int min = ArrayTool.getMin(arr);//获取arr中最小值

System.out.println(min);

System.out.println(max);

ArrayTool.printArray(arr);

ArrayTool.selectSort(arr);//给arr排序 从小到大

ArrayTool.printArray(arr);

int[] arr2 ={3,1,87,32,8};

ArrayTool.printArray(arr2);

ArrayTool.bubbleSort(arr2);//用冒泡法给arr2排序 从小到大

ArrayTool.printArray(arr2);

}

}

 * 设计模式：解决某一里问题最行之有效的方法。

 * java中有23种设计模式：

 * 单例设计模式：结果一个类在内存中只存在一个对象

 *

 * 想要保证对象唯一

 * 1，为了避免其他程序过多建立该对象，先进禁止其他程序建立该对象

 * 2、还为了让其他程序可以访问到该类对象，治好在本类中，自定义一个对象

 * 3、为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式。

 *

 * 代码实现

 * 1、将构造函数私有化

 * 2、在类中创建一个本类对象

 * 3、提供一个方法可以获取到该对象

 *

 *

 * 对于事物该怎么描述，还怎么描述。

 * 当需要将该事物的对象保证在内存中唯一时，就将以上的3步加上即可。

 **/

“饿汉式” 常用

class Single

{

private Single () {}

private static Single s = new Single();

public static Single getInstance()

{

return s;

}

“懒汉式”

class Single1

{

private static Single1 s = null;

private Single1 () {}

public static Single1 getIstance()

{

if(s==null)

{

synchronized (Single.class) {

if(s==null)

s = new Single1();

}

}

return s;

}

}

记录原则：定义单例，建议使用饿汉式

Task1第七天（2017年5月21日）

今日计划

继续学习夯实基础

继承：

1、提高了代码的复用性

2、继承让类与类产生关系。有个这个关系才有了多态的特性。

 * 子父类出现后，类成员特点：

 * 类中成员：

 * 1、变量

 * 2、函数

 * 3、构造函数

 *

 * 1、变量

 * 如果子父类中出现了非私有的同名成员变量时

 * 子类要访问本类中的变量，用this

 * 子类要访问父类中的同名变量，用super

 *

 * super的使用与this 的使用几乎一致

 * this代表的是本类对象的引用

 * super代表的是父类对象的引用

 *

 * 2.子父类中的函数。

 * 当子类出现和父类一模一样的函数时。

 * 当子类对象调用该函数，会运行子类函数的雷荣

 *

 * 这种情况是函数的另一个铁兴：重写（覆盖）

 *

 *

 * 当子类继承父类，沿袭了父类的功能，到子类中，

 * 但是子类虽具备该功能，但功能的内容却和父类不一致。

 * 这是，没有必要定义新功能，而是使用覆盖功能，保留父类功能定义，并重写功能内容。

 *

 * 覆盖：

 * 1、子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。

 * 2、静态只能覆盖静态。

 *

 * 重载：只看同名函数的参数列表

 * 重写：子父类方法要一模一样。

final：最终，作为一个修饰符。

1、可以修饰类，函数，变量。

2、被final修饰的类不可以被继承.为了避免被继承，被子类重写功能。

3、被final修饰的方法不可以被重写

4、被final修饰的变量是一个常亮只能赋值一次，既可以修饰成员变量，又可以修饰局部变量。

  当在描述事物时，一些数据的出现值是固定的，那么这是为了增强阅读星，都给这些值起个名字，方便阅读

 而这个值不需要改变，所以加上final修饰。作为常量的书写规范，所有字母都大写，如果由多个单词组成。

 单词间通过_连接。

 5、内部定义在类中的局部位置上，只能访问该局部被final修饰的局部变量

 抽象类

抽象类的特点：

 1、抽象方法一定在抽象类中

 2、抽象方法和抽象类都必须被abstract关键字修饰

 3、抽象类不可以用new创建对象。因为调用抽象方法没有疑议

 4、抽象类中的抽象方法要被使用，必须由子类复写起所有抽象方法后，建立子类对象调用。

  如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

接口

class 用于定义类

interface 用于定义接口

  接口定义时，格式特点：

接口中常见定义：常亮，抽象方法。

接口中的成员都有固定修饰符。

常亮修饰符是public static final

方法public abstract

记住：接口中的成员都是public的

接口是不可以创建对象的，因为有抽象方法。

需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化

否则子类是一个抽象类

接口还可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。

接口的特点：

1、接口是对外暴露的规则。

2、接口是程序的功能扩展。

3、接口可以用来多实现。

4、类与接口之间是实现关系，而类可以继承一个类的同时实现多个接口。

5、接口与接口之间可以有继承关系。

收获

学习了继承，final，接口等知识，对之前模仿编写的DAO中各类之间的关系有了更清晰的认识。