JAVA学习笔记整理二（面向对象）

面向对象

1.“面向过程”与“面向对象”

 1）面向过程：想到什么地方就做什么地方

 2）面向对象：有模板的开发，分模块开发

      

2．面向对象的特性：

1）封装性

     封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。

2）继承性

     继承是子类利用父类中定义的方法和变量就像它们属于子类本身一样.

3）多态性

     通过覆盖父类的方法来实现，在运行时根据传递的对象引用，来调用相应的方法

      

类与对象

1. 把相似的对象划归成一个类。

2. 在软件中，类，就是一个模板，它定义了通用于一个特定种类的所有对象的状态（变量）和行为（方法）。

3. 没有类就无法产生对象，类是创建对象的模板，对象是类的实例

局部变量

1.  方法中定义变量是局部变量，只能在该方法中使用

2.  局部变量的定义不能加public、private、protected、static修饰符

3.  局部变量在使用之前必须进行初始化

方法

1.  方法是一个命名的代码块，用来完成一定的特殊功能，它可以输入不同的自变量，而得到不同的返回值，它可以把程序中特定的功能块组合到一起，便于多次使用，也能使程序结构变得清晰

2.  方法的声明中必须包含返回值类型，如果方法没有返回值，返回值的类型应写为void

3.  如果方法需要返回一个值，则应保证在任何情况下都要返回一个与返回值类型相匹配的值，抛出异常除外

4.  方法在调用时必须提供和其声明格式相匹配的参数值

构造方法

1.  构造方法是在类实例化时执由虚拟机自动调用的一段代码，主要用于成员变量的初始化，我们在实例化一个对象时的形式是由构造方法的形式决定的

2.  构造方法的名字和类名相同，并且没有返回值，也不能加void

3.  除构造方法外，其它的方法不能调用构造方法

4.  Java的类都要求有构造方法，如果没有定义构造方法，Java编译器会为我们提供一个缺省的构造方法，也就是不带参数的构造方法，但如果我们编写了带参的构造方法，则系统会收回不带参数的构造方法

5.  构造方法调用时必须写在第一行，并且不能直接写方法名，需要this（参数）

    

    

this变量

1.  this变量代表对象本身

2.  当类中有两个同名变量，一个属于类（类的成员变量），而另一个属于某个特定的方法（方法中的局部变量），使用this区分成员变量和局部变量。

    

3.  使用this简化构造方法的调用，即可以在一个构造方法中使用this调用本类的另一个构造方法。

    

super关键字

 super关键字可以从子类中调用父类中的构造方法、普通方法和属性，每个子类构造方法的第一条语句，都是隐含地调用super()（即若是父类仅为普通构造方法，则子类的构造方法的第一句的“super()”可写可不写；但若父类中有重载的构造方法，则必须写且参数个数属性等均一样）

this与super的区别

     

this与super不可同时出现，都必须放在构造方法的首行，并且如果在子类中使用，则不管怎么操作都必须先调用父类中的构造方法

static关键字

1.  如果在属性或方法的声明中加上static修饰符，则称该属性或方法是静态的（全局的）

    

2.  静态的属性和方法与类绑定，非静态的属性和方法与对象绑定，静态的属性在整个应用中只有一份，而非静态的属性每个对象一份

3.  静态方法和静态变量是属于某一个类，而不属于类的对象。

4.  静态方法和静态变量的引用可直接通过类名引用，也可以通过对象去引用（建议：使用类名而非对象名访问类的静态属性与方法）

5.   在静态方法中不能调用非静态的方法和引用非静态的成员变量（所以，由于主方法为静态的，所以要由主方法直接调用的方法必须用static声明），但是非静态的方法可以调用静态方法

new关键字的作用

1.  为对象分配内存空间（分配内存存储中定义的变量和方法）

2.  调用类的构造方法或构造对象

3.  为对象返回一个引用

final关键字

1.  使用final声明的类不能有子类

2.  使用final声明的方法不能被子类所覆盖

3.  使用final声明的变量即成为常量，不可以修改（声明时，要求全部的字母大写）

4.  如果一个程序中的变量使用public static final声明，则此变量将称为全局常量

5.  class中所有的pravate和static方法自然就是final

instanceof关键字

用于判断一个对象到底是哪个类的实例

格式：对象 instanceof 类（返回boolean类型）

代码块

即用“{}”括起来的一段代码，根据位置的不同，分为以下4种：

1.  普通代码块：指直接在方法中或是语句中定义的代码块

2.  构造块：直接写在类中的代码块（在构造方法之前执行，且每次实例化对象都会执行构造块中的代码）

3.  静态代码块：在代码块之前用static关键字声明的代码块（优先于主方法执行）

4.  同步代码块：

  动态的代码块，先于构造方法执行

  代码块在创建每一个对象时在构造方法之前执行，静态代码块在类第一次装载的时候执行，在整个系统中只执行一次

单例（Singleton）设计模式

1.  一个类只有一个实例，而且自行实例化并向整个系统提供这个实例，这个类称为单例类（不管外面如何使用，最终结果只有一个实例化对象存在）

2.  单例类的一个最重要的特点是类的构造方法是私有的，从而避免了外部利用构造方法直接创建多个实例。

三步骤：1.  将函数私有化

               2.  在本类中自定义一个对象

               3.  提供一个方法可以访问到该类的对象

    

封装性

1.  使用private将一些属性进行封装，使对象无法直接访问类中的属性，而利用setter与getter方法设置和取得，从而可以在setter方法中对这些属性进行其他操作（例如：可以对属性进行检查，看是否满足所需的条件）

2.  面向对象的封装性本身并不是单单指private关键字，而用private声明的属性或方法只能在本类的内部被调用，而不能在类的外部被调用

继承性

1.  子类拥有父类的所有的属性和方法但不能访问父类中的私有属性与方法

2.  子类的构造方法一定会调用父类的构造方法，默认调用不带参的构造方法

3.  构造方法不能被继承，在子类中用super()来调用父类的构造方法

4.  可以用super访问父类被子类隐藏的变量或覆盖的方法

String

  常用函数列表

    

String s = "  Hello java,hello android,hello OOP,HELLO String,hello JAVASE!";
System.out.println("原始字符串：" + s);
//	原始字符串：  Hello java,hello android,hello OOP,HELLO String,hello JAVASE!
System.out.println("转换为大写：" + s.toUpperCase());
//	转换为大写：  HELLO JAVA,HELLO ANDROID,HELLO OOP,HELLO STRING,HELLO JAVASE!
System.out.println("转换为小写：" + s.toLowerCase());
//	转换为小写：  hello java,hello android,hello oop,hello string,hello javase!
System.out.println("字符串拼接：" + s.concat("Hello concat"));
//	字符串拼接：  Hello java,hello android,hello OOP,HELLO String,hello JAVASE!Hello concat
System.out.println("查找java的位置：" + s.indexOf("java"));
//	查找java的位置：8
System.out.println("从字符串最后查找java的位置：" + s.toLowerCase().lastIndexOf("java"));
//	从字符串最后查找java的位置：56
System.out.println("字符串长度：" + s.length());
//	字符串长度：63
System.out.println("去空字符：" + s.trim().length());
//	去空字符：61
System.out.println("replace：" + s.replace("hello", "hi"));
//	replace：  Hello java,hi android,hi OOP,HELLO String,hi JAVASE!
System.out.println("replaceAll:" + s.replaceAll("hello", "hi"));
//	replaceAll:  Hello java,hi android,hi OOP,HELLO String,hi JAVASE!

s = "file.txt";
System.out.println("s.endsWith(\".java\"):" + s.endsWith(".java"));
//	s.endsWith(".java"):false

s = "d:\\test\\test.java";
System.out.println("路径是否是D盘：" + s.startsWith("d:\\"));
//	路径是否是D盘：true

String[] sarr = "1,2,3,4,5,6,7".split(",");
sarr="2016-10-10".split("-");
System.out.println(Arrays.toString(sarr));
//	[2016, 10, 10]
System.out.println(Integer.parseInt(sarr[1]);
//	true

System.out.println("字符串"+6);
//	字符串6
System.out.println("字符串"+String.valueOf(6));
//	字符串6

方法的覆盖（override）

1.  在子类中定义一个与父类同名、返回类型、参数类型均相同一个方法，称为方法的覆盖

2.  覆盖方法的返回值类型必须与它所覆盖的方法相同

3.  覆盖方法不能比它所覆盖的方法的访问性差

4.  覆盖方法不能比它所覆盖的方法抛出更多的异常

方法的覆盖与重载的区别

1.  方法的覆盖是子类和父类之间的关系，而重载可以是发生在一个类内部多个方法间

2.  方法的覆盖一般是两个方法间的，而重载时可能有多个重载方法

3.  覆盖的方法有相同的方法名和形参表，而重载的方法只能有相同的方法名，不能有相同的形参表

4.  覆盖时区分方法的是根据调用他的对象，而重载是根据形参来决定调用的是哪个方法

5.  用final修饰的方法是不能被子类覆盖的，只能被重载

多态性（两种体现）：

1.方法的重载与覆盖

2.对象的多态性

  1）向上转型（子类对象→父类对象）：程序自动完成

   2）向下转型（父类对象→子类对象）：必须明确的指明要转型的子类类型，向下转型前，必须首先发生对象向上的转型，否则将出现对象转换异常

class A{
	public void fun1() {
		System.out.println("A--->public void fun1()");
	}
	public void fun2() {
		this.fun1();
	}
}
class B extends A{
	public void fun1() {
		System.out.println("B--->public void fun1()");
	}
	public void fun3() {
		System.out.println("B--->public void fun3()");
	}
}
public class Transition {
	public static void main(String[] args) {
		B b = new B();//定义子类实例化对象
		A a = b;//发生了向上转型的关系，子类→父类
		a.fun1();//此方法被子类覆写过，所以调用的是被子类覆写后的方法
		//结果：B--->public void fun1()
//		a.fun3();//无法调用，因为在父类中并没有定义，如果想调用，则需要将对象向下转型
        test();
		//结果：B--->public void fun1()
		//结果：B--->public void fun1()
		//结果：B--->public void fun3()
	}
	private static void test() {
		A a = new B();//发生了向上转型的关系，子类→父类
		B b = (B)a;//发生了向下转型的关系
		b.fun1();//调用被子类覆写后的方法
		b.fun2();//调用父类的方法
		b.fun3();//调用子类自己的方法
	}
}

Object类

Object类是所有类的基类，如果一个类的定义中没有继承任何类，这个类默认继承自Object类

Public Object()                                      构造方法

protected Object clone()                       用来生成当前对象的一个拷贝，并返回这个复制对象。

public boolean equals(Object obj)        用来比较两个对象是否相同。

public Class getClass()                         用来获取当前对象所属类的信息，返回class对象

protected void  finalize()                       用来定义回收当前对象时所需完成的清理工作。

public int hashCode()                           用来返回当前对象的散列码

public String toString()                         用来返回当前对象本身的有关信息，按字符串对象返回。

（加不加toString方法，最终结果都一样，也就是说对象输出时一定会调用该方法打印内容，利用该特性，可以在类中覆写toString方法）

public class Person {
	private int id;
	private String name;
	public Person(String name,int id){
		this.name = name;
		this.id = id;
	}
	@Override
	public String toString() {
		return "姓名：" + name + ", 编号：" + id;
	}
}

当实例化该对象时，即可直接打印出实例化后的方法

public class TestSomeMethod {
	public static void main(String[] args) {
		Person person = new Person("小五",18);
		System.out.println("对象信息：" + person);
		//结果：对象信息：姓名：小五, 编号：18
	}
}

高级访问控制

1.类的访问说明符

     1、public :能被其它所有的类访问和引用， 可使用 import从另一个包中引入所需要的类，但被 引入的类必须是public 修饰。

     2、默认（friendly）:只能被同一个包中的类访问和 引用，一个.Java文件最多有一个public修饰的类，且该类的名称要与.java的文件名一致。

 2.方法的访问说明符

     1、public :如果类也是public 修饰的话，这些属性和方法可以被所有的类访问和使用

      2、 private:只能被该类自身访问和调用

      3、protected:保护访问控制符，可被同一个包中的类或不同包中该类的子类以及该类自身访问和引用      

      4、默认：具有包内访问性，只能被同一个包中的其他类访问和引用