java面向对象编程

Java的学习的第十一天

面向过程与面向对象的区别

1.面向过程：主要强调的是功能行为，最小单位是函数，考虑是怎么做；
2.面向对象：主要强调的是功能的对象，最小单位是类或者对象，考虑的是找谁做；

面向对象的三大特征：

一、封装性
两个含义：
1、把对象的属性和行为看成一个密不可分的整体，将这两者“封装”到一个不可分割的独立单位（即对象）之中。
2、把“信息隐藏”，把不需要让外界知道的信息隐藏起来，有些对象的属性及行为允许外界用户知道或者使用，但不允许更改，而另一些属性和行为，则不允许外界知晓。

二、继承性
面向对象继承的机制，大大增强了程序代码的可复用性，提高了软件开发的效率，降低了程序产生错误的可能性，也为程序提供可修改的便利。
一个子类只能继承一个父类，不支持多继承，故通过Interface接口来弥补不能多继承的遗憾。

三、多态性
Java语言中有两种形式表现多态，即方法的重载，对象的多态。

引用传递

引用传递的核心概念：
一块堆内存空间（保存对象的属性信息） 可以同时被多个栈内存所指向，则每一个栈内存都可以修改一个堆内存空间的属性值。

构造方法

实例化对象的格式：
类名称 对象名称 = new 类名称( )；
下面对格式的每一个标记进行解释：
类名称：要定义对象的数据类型；
对象名称：需要一个名字对日后修改类属性和方法操作进行标记。
new：开辟新的堆内存空间；
类名称（）：表示实例化对象，此处表示调用了类中的构造方法。

构造方法和普通方法不一样的地方：
构造方法是实例化对象时使用，而普通方法是实例化对象产生后使用的。

构造方法定义要求如下：
1、构造方法的名称和类名保持一致；
2、构造方法不许有返回值类型声明；
3、由于对象实例化操作一定需要构造方法的存在，所以如果在类之中没有明确定义构造方法的话，则会自动生成一个无参、无返回值得构造方法供用户使用，也就是说一个类之中至少存在一个无参的构造方法；

数组

声明并开辟一个数组（实例化一个数组）
数组类型 数组名称 [] = new 数据类型[长度]；
数据类型 [] 数组名称 = new 数据类型[长度]；

数组最常见的两个异常就是：
NullPointerException
ArrayIndexOutOfBoundsException

数组的静态初始化
数组类型 数组名称 [] = new 数据类型[] {值，值…}
数据类型 [] 数组名称 = new 数据类型[] {值，值…}

String类

字符串比较
“==”属于数值判断——判断的是两个对象的内存地址数值，并没有判断内容。
“equals()”属于内容判断——比较的不再是内存地址的数值，而是两个字符串的内容。

观察入池问题
String str1 = “hello”；//入池
String str2 = “hello”；//使用池对象
String str3 = “hello”；//使用池对象
这三个字符串对象的内存地址完全相同，也就是说这三个实际上只开辟了一个堆内存空间，不同的字符串对象都指向了同一堆内存空间。

-----手工入池------
通过public String intern()方法调用，通过使用.intern()调用该方法。

String str = new String("Hello").intern();

String常用方法（重点）

字符串与字符

字符串与字节

字符串与字节

字符串的比较

以下为compareTo()方法的范例：（注意图中上面那段话）

字符串查找

字符串替换

字符串截取

字符串拆分

其他方法

this关键字

“this.属性”表示本类属性
调用本类方法
调用本类方法有两种：
1、调用本类的普通方法，用“this.方法()”调用。
2、调用本类的构造方法，用“this()”调用。

this.方法（）：先从本类查找是否存在指定的方法，如果没有找到，则调用该父类操作；
super.方法（）：直接由子类调用父类之中的指定方法，不再找子类。

调用本类构造方法的例子：

“this”表示当前对象

this可以用于对象对比例子如下：

this和super的区别面试题

static关键字的使用

如果希望某个属性定义为公共属性（所有对象都可以使用的属性），则可以在声明属性的时候加上关键字static。

使用static定义要注意的几个点：

使用static关于方法的调用：

代码块

代码块一共分为四种：普通代码块、构造块、静态块和同步块

构造块的执行优先于构造方法。
静态块的执行优先于构造块又优先于构造方法。静态块只会执行一次，不管有多少个实例化对象，它的主要作用就是为类中的static属性初始化。
静态块要考虑两种情况：
1、在非主类中dingyi的构造块；
2、在主类中dingyi的构造块；

内部类

内部类和外部类之间的私有属性可以相互访问，在内部类访问外部类的属性时采用了“Outer.this.属性，表示即将访问Outer类对象的属性。
实例化内部类的操作有两种格式：
格式一（非static定义内部类）：
外部类.内部类 内部类对象 = new 外部类().new 内部类();
格式二（static定义内部类）：
外部类.内部类 内部类对象 = new 外部类.内部类();

单向链表（看不太懂再看一看）

链表实际上可以理解为一串对象数据，，或者专业点理解为动态的对象数组。

3.19.3开发可同链表中开发链表的方法及功能

覆写

方法的覆写
如果父类的方法权限为private，则子类无法覆写，一般情况下也不会这样去编码。

属性的覆盖

重载和重写的区别面试题

final关键字

1、使用final定义的类不能有子类，即无法被其他类所继承。
2、使用final定义的方法不能够被子类所覆写。
3、使用final定义的变量，就表示常量，常量在定义的时候必须设置默认值，并且不能被修改。（final定义的常量单词都必须大写）

构造方法私有化

如果一个类只希望有唯一的一个实例化对象出现，那就应该控制构造方法，如果构造方法对外部不可见了，那么现在肯定无法执行对象的实例化操作，必须将构造方法隐藏，使用private隐藏。
不想要在getter方法中出现实例化对象，破坏了唯一的实例化对象这个期望，就使用final关键字，使得它只能被使用一次。

例子如下：

在以后使用Singleton类时，无论代码如何操作，永远只会存在唯一一个Singleton类的实例化对象，而这样的代码，在设计模式上就称为单例设计模式。
如上述程序所示其特点：
构造方法被私有化，只能沟通过getInstance()方法取得Singleton类的实例化对象，这样不管外部如何操作，最终也只有一个实例化对象，在单例设计模式中一定会存在一个static方法，用于取得本类的实例化对象。
在以后的开发中，Spring框架上会大量地应用单例这个概念，处理不当会造成代码执行混乱。

多例设计模式

单例设计模式只有留有一个类的一个实例化对象，而多例设计模式会定义出多个对象，如定义一个性别类，只能实例化对象（男，女），这种情况下，这样的类就不应该有用户无限制创造，该有几个就是几个，这就属于多例设计。不管是多例设计还是单例设计，有一个共同不变的核心就是——构造方法私有化。

多态性

A为父类，B为子类。
向上转型：格式：父类 父类对象 = 子类实例 模板：A a = new B();
向下转型：格式：子类 子类对象 = (子类)父类实例 模板：B b = (B) a;

当对象发生向下转型关系前，一定要首先发生向上转型关系。

如果想要判断某一个对象是否是某一个类的实例，只需要使用instanceof关键字即可，此操作的语法如下：
格式： 对象 instanceof 类
返回boolean类型的值

多态性的机制是什么？ 面试题

抽象类

普通类其中的方法都已经实现差不多完整，抽象类中最大的特点就是包含了抽象方法，抽象方法是声明而未实现的的方法，抽象方法定义时要使用abstrac关键字完成，并且抽象方法一定要在抽象类中。
注意：抽象类不是一个完整的类，所以不能像普通类一样直接实例化对象。
抽象类使用原则如下：
1、抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；
2、子类（如果不是抽象类）必须覆写（重写）抽象类中的全部抽象方法；
3、抽象类对象可以使用的向上转型方式，通过子类来进行实例化操作；

抽象类中的各类问题（重点！！！）

当我们学习到了Servlet开发部分的时候，我们会使用抽象类进行类定义模板的功能。因为所有的Servlet一定要继承HttpServlet类，而HttpServlet类会根据用户发出不同的请求（每一种请求都通过了一个常量表示）调用不同的方式进行处理，get请求，就使用doGet()方法，post请求，就使用doPost()方法。

接口

接口属于一种特殊的类，如果一个类定义时全部由抽象方法和全局常量组成，那么就成为接口。
定义接口的例子：

interface A{
	public static final String INFO = "Hello World";
	public abstract void print();
}
interface B{
	public abstract void get();
}

接口使用原则：
1、每一个接口必须定义子类，子类使用implements关键字实现接口；
2、接口的子类（如果不是抽象类）必须覆写接口中所定义的全部抽象方法；
3、利用接口的子类，采用对象的向上转型方式，进行接口对象的实例化操作

如果一个类既要实现接口又要继承抽象类，则应该先继承抽象类后实现接口的方式完成。

接口的全部组成就是抽象方法和全局常量，所以可以写成以下简化版的定义。

接口中的访问权限只有一种：“public”，即使没有写上“public”，最终的权限也是“public”。

接口可以定义一个标准，比如说Usb这个接口的标准。

工厂设计模式（Factory）
把A→B直接指向，万一出了问题就很难进行修改，转换成A→C→B模式，加入个中间类class Factory(){}使得代码更加具有可修改性。
代理设计模式（Proxy）
代理设计也是java开发中使用比较多的一种设计模式，所谓的代理设计就是指一个代理主题来操作一个真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。

抽象类和接口的区别（面试题）

匿名内部类

定义匿名内部类：

Object类

定义一个类，如果没有默认继承哪个类的话，就默认继承Object类。
Object可以接受任意类：
Object obj = new Person();//向上转型
Person per = (Person) obj;//向下转型
对于任意一个简单的java类而言，理论上应该重写Object类中的三个方法：
1、取得对象信息：public String toString();
2、对象比较：public boolean equals(Object obj);
3、取得哈希码：public int hashCode();

有上述代码中我们可以看到，直接输出对象和通过对象调用toString()方法输出了都是对象地址。故对象默认调用了toString()方法。

包装类

java为我们提供了八种专门的包装类：
byte(Byte)、short(Short)、int(Integer)、long(Long)、float(Float)、double(Double)、boolean(Boolean)、char(Character)
而这八种包装类分为数值型和对象型
对象型：Boolean、Character
数值型：Byte、Short、Integer、Long、Float、Double
对于数值型（Number）类中定义的方法可以从包装的类中取得所包装的数值:byteValue()、shortValue()、intValue()、longValue()、floatValue()、doubleValue()。

拆箱装箱
装箱操作：将基本数据类型变为包装类，称为装箱；
拆箱操作：将包装类变为基本数据类型，称为拆箱。
以int类型为例子：
Integer var = new Integer(15);//装箱
int result = var.intValue();//拆箱

自动拆装箱例子：
Integer var = 15;//自动装箱
int result = var;//自动拆箱

数据转型
包装类最大的优点还在于可以把字符串变为指定的基本数据类型
Integer类：public static int parseInt(String s);
Double类：public static double parseDouble(String s);
Boolean类：public static boolean parseBoolean(String s);
但是在Character这个包装类中没有提供parsecharacter这个方法，因为字符串String类中提供了一个charAt()方法，可以取得指定索引的字符，并且一个字符的长度就是一位。

基本数据类型转变为字符串：
例子：将int型变为String类型
方法一：

public class TestDemo{
public static void main(String args[]){
int num = 100;
String str = num + ""'
System.out.println(str,length());
	}
}

运行结果：
3

方法二：
利用String类的方法valueOf（数据类型 变量）

public class TestDemo{
public static void main(String args[]){
	int num = 100;
	String str = String.valueOf(num);
	System.out.println(str.length());
	}
}

运行结果：
3