Java笔记：面向对象（一）

面向对象：

三大特点：封装、多态、继承.

1，类和对象

1，类：某一批对象的抽象，就好比人类，手机类，他们拥有相似的特点，属性。
2，对象：也就是实例，是一个具体存在的实体，日常说的人是人类这个类的实例；华为手机，小米手机是手机这个类的实例。
3，定义一个类的简单语法如下：

[修饰符] class 类名         修饰符可以是 public、final、abstract
{
	零到多个构造器定义..	   构造器名必须和类名相同
	零到多个成员变量...
	零到多个方法...
}

4，成员变量的语法格式：

[修饰符] 类型 成员变量名;

修饰符可以是public、protected、private、static、final,其中public、protected、private三个中只能出现其一，可以与static、final组合起来修饰成员变量。
5，static所修饰的成员变量与方法属于这个类本身，而不属于该类的单个实例，被static修饰的方法与成员变量被称为类方法，类变量或者静态方法，静态变量；通常也把不使用static修饰的成员变量和方法称为实例变量，实例方法或者非静态变量，非静态方法。对于static修饰的方法而言，可以直接使用类来调用该方法而无需创建实例。
6，Java提供了this指针，总是指向调用该方法的对象，例：

public class father{
	private int age;
	public void set_age(int age){
		this.age = age;               这里this指针指向的是这个类里的age，属于该方法的对象
	}
}

7，静态成员不能直接访问非静态成员，如果确实需要在静态方法中访问另一个普通方法，只能重新创建一个对象

2，方法

1，方法由传统的函数发展而来，却又有显著不同：在结构化编程语言里，函数是一等公民，整个软件由一个一个函数组成，而在面向编程语言里，类才是一等公民，整个系统由一个一个类组成
2，定义方法的语法：

[修饰符] 方法返回值类型 方法名(形参列表)
{
	//由零到多条可执行性语句组成的方法体
}

3，方法的参数传递:只有一种方式，值传递，就是将实际参数值的副本(复制品)传入方法内，而参数本身不会受到影响。但当传入的值类型是引用类型的值时，因其传入的实际是存储数据的地址，所以改变形参时，实参会收到相应的变化
4，形参可变的方法：在最后一个形参的类型后加三点(…)，例：

public class Varargs{
	public static void test(int a, String... books){
		方法执行体
	}
}

5，方法重载：Java允许同一个类里多个同名方法，只要形参列表不同就行，如果同一个类中包含了两个或两个以上方法的方法名相同，则被称为方法重载。

3，成员变量与局部变量

1,区分：
成员变量：在类里定义的变量。
局部变量：在方法内定义的变量。
2，成员变量分两种：类变量与实例变量，如果通过一个实例来访问修该了一个类变量，由于这个类变量不属于它，而是属于它对应的类，因此修改的依然是类的类变量。成员变量作用范围对整个类有效。不能两个同名的成员变量。成员变量保存在堆内存中。
3，局部变量除形参外，都必须显式初始化。局部变量不能与形参同名。局部变量保存在其方法的栈内存中。
4，允许局部变量与成员变量同名，局部变量会覆盖成员变量。

4，隐藏与封装

1，封装：指的是将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，而是通过该类所提供的方法来实现对内部信息的操作和访问。该隐藏的隐藏，该暴露的暴露。

public class Person{
	private String name;
	private int age;            将内部信息隐藏起来
	public void setName(String name){
		this.name = name;       提供方法来操作隐藏的信息
	}
	public  String getNnme{
		return this.name;
	}
	.......	
}

2，访问级别由小到大：private、default、protected、public。
(1)private：这个类成员只能在当前类的内部被访问。
(2)default：可以被相同包下的其他类访问。
(3)protected：可以被同一包中的其他类访问，也可以被不同包中的子类访问，如果用protected来修饰一个方法，通常是希望其子类来重写这个方法。
(4)public：公共访问权限。
3，包
(1)，包：一组功能相似的类所存放的类库单元package，如果希望把一个类放在指定的包结构下，应该在类上加：

package packageName;

一个原文件只能指定一个包，即只能包含一条package语句。
(2)，包的使用：
关键字import.
导入单个类：

import package.subpackage...ClassName;

导入指定包的全部类：

import package.subpackage...*;

导入指定类的单个静态成员变量、方法：

import static package.subpackage...ClassName.fieldName|methodName;

导入指定类的全部静态成员、方法：

import static package.subpackage...ClassName...*;

5，构造器

1，作用：最大的用处就是在创建对象时执行初始化。Java类必须包含一个或一个以上的构造器。当程序员调用构造器时，系统会先为该对象分配空间，并为这个对象执行默认初始化，这个对象已经产生了，这些操作在构造器执行前就都完成了，也就是说，当系统开始执行构造器的执行体之前就已经创建了一个对象，只是这个对象还不能被外部程序访问，只能在该构造器中通过this来引用，当构造器的执行体执行后，这个对象作为构造器的返回值被返回。
2，构造器也可重载，和方法重载相同

6，类的继承

1，特点：单继承，每个子类都只有一个直接父类，但有很多间接父类。被继承的称为父类，继承的为子类，父类包含的范围总比子类所包含的范围要大，可以认为父类是大类而子类是小类。Object类是所有类的父类。
2，关键字：extends;语法：

[修饰符] class SubClass extends SuperClass{
	类定义部分
}

3，重写：重写父类方法，子类包含与父类同名方法的现象，也被称为方法覆盖。所遵循的规则：方法名，形参列表相同，子类方法返回值类型应比父类方法返回值类型更小或相等，子类方法声明抛出的异常类应比父类的更小或相等，字类的访问权限应比父类的大或相等 覆盖的方法和被覆盖的方法都只能是实例方法，不能两个不一样
4，super,如果需要在子类方法中调用父类被覆盖的实例方法，可用super限定来调用，super也不能出现在static修饰的方法中。例：

public class BaseClass{
	public int a = 5;
}

public class SubClass extends BaseClass{
	public int a = 7;
	public void accessOwner(){
		System.out.println(a);           输出7
	}
	public void accessBase(){
		System.out.println(super.a);     输出5
	}
}

5，如果在子类中定义了与父类已有的同名变量，子类的会隐藏父类的，但不是完全覆盖，在创建子类对象时，依然会为父类中定义的、被隐藏的变量分配内存空间
6，父类构造器总会在子类构造器前执行，执行父类构造器时会一直上溯到其父类的构造器，最先执行的总是java.lang.Object类的构造器。

7，多态

1，Java引用变量有两个类型：一个是编译时类型，一个是运行时类型。编译时类型由声明该变量时使用的类型决定，运行时由实际赋给该变量的对象决定。如果编译时类型和运行时类型不一样，就可能出现所谓的多态。
2，Java允许把一个子类对象直接赋值给一个父类引用变量，无需任何类型转换，称为：向上转型。当运行时调用该应用变量时，其方法行为总时表现出子类方法的行为特征。引用变量只能调用声明该变量时所用类里包含的方法例：

Object p = new Person();  这个p只能调用Object类的方法，而不能调用Person类里定义的方法。

3，引用类型的强制转换：如果需要让这个引用变量调用他运行时类型的方法时，必须把它强制转换成运行时类型，类型转换运算符：

(type)variable 可将variable转换成一个type类型的变量

注意：数值类型和布尔类型之间不能进行类型转换；引用类型的转换只能在具有继承关系的两个类型之间进行。
4，instanceof,在进行类型转换之前，先用instanceof进行判断是否可以进行类型转换，避免出现ClassCastException异常，保证程序更加健壮。用法：
5，多态的注意点：
(1)，尽量隐藏父类的成员变量，不要让子类直接访问到。
(2)，不希望子类重写的方法可用final修饰。
(3)，希望被子类重写但不希望被其他类自由访问，可以用protected修饰该方法。
(4)，尽量不要在父类构造器中调用将要被子类重写的方法，可能会引发空指针异常。
6，组合：实现类复用来提供更好的封装性，把旧类对象作为新的成员变量组合进来。

ClassA instanceof ClassB; ClassA要么是ClassB的子类，要么和它是一个类型

8，初始化块

1，作用：与构造器的作用非常相似，也可以对Java对象进行初始化操作。语法：

[修饰符] {                   如果有修饰符，只能是static                 
	初始化块的可执行代码
	......
}

2，使用static修饰的初始化块被称为类初始化块，没有的就叫实例初始化块，一个类里可以有多个初始化块，但大可不必。实例化初始化块只在创建实例时隐式执行，而且在构造器之前自动执行。类初始化块则在类初始化阶段自动执行