【JAVA】学习笔记③：面向对象基础

一、类

具有相同特征的事物的抽象描述，是抽象的、概念上的定义。
编程时先根据客观的事物进行抽象(设计为程序)，然后由抽象创造出具体，最终使用的是具体。

类的结构

访问权限修饰符(public protected privite 无)
修饰符(final abstract)
用class来修饰类
例：在Car类中，对汽车属性和功能进行定义

public class Car
{
	String name; //名字
	float price; //价格
	String color; //颜色
/*
成员变量(因为变量直接定义在类中，所以称为类的成员)
成员变量在类定义时，可以不给其赋默认值，系统会自动初始化赋值
默认值：
引用类型--false
float--0.0
int long--0
boolean--false
char--' '
名词，属性
*/

/*
成员方法
动词-->行为、功能
*/
}

类是抽象概念，不能直接拿来使用，若要使用，要创建类的实例
第一步：发现类
第二步：定义类的成员变量
第三步：定义类的成员方法
第四步：使用类创建对象，最终使用的是对象

二、对象

实际存在的该类事物的每个个体，是具体的，因而也称为实例
对象是类的实例，是以类为模板，在内存中创建出的一个实际存在的实例(对象)

如何创建对象

使用new关键字创建对象，如new Car() 使用new关键字创建一个具体的对象，对象存在内存中
同一个类的每个对象有不同存储空间

三、类与对象的关系

类是模板，是定义
对象是具体实例

四、构造方法

特点：方法名字与类名相同
没有返回值，不需要void修饰
作用：为刚创建的对象成员变量进行初始化赋值
创建对象时，调用的是无参的构造方法初始化对象成员，先赋予默认值

五、方法重载

在一个类中，有多个名称相同的方法
如何在调用时区分同名的方法：
通过方法的参数的个数，类型，顺序区分方法
方法的重载与返回值类型没有关系
在类中创造的方法有参时，系统自带的无参的创造方法就会被覆盖。若想要用无参的创造方法进行调用，需在类中加上无参的创造方法的结构。

六、对象与引用

java 语言中除基本类型之外的变量类型都称之为引用类型
java中的对象是通过引用对其操作的

值传递

基本类型作为参数传递，形参改变后，实参是没有影响，使用实参的值，填充了形参，是两个独立的变量。

引用类型传递

引用数据类型作为参数传递，传递的只是对象的地址，实参和形参指向的是同一个对象，任何一方改变对象的值，另一方也会改变。

七、相关的关键字

1、this关键字

在类中用来表示当前正在访问的对象，如this.成员变量名–显示的访问当前对象的成员变量
在类中的某个构造方法中，使用this调用另一个构造方法

2、static关键字

static–静态，可以用来修饰类的成员变量，成员方法，代码块，内部类等
static静态属性在内存中只存在一份，所有对象共享这一份静态成员变量
static修饰属性(成员变量)

static关键字修饰的属性特点：

静态成员变量也称为类变量，在内存中只有一份，所有对象可以共享，一般情况下，将类中所有对象相同的属性设置为静态的。

static修饰内容

随着类的加载而加载，类只需被加载了就可以直接通过类名访问，其优先于对象存在，静态成员被所有的对象共享。
推荐直接用类名去访问该静态成员。
一旦方法中，使用了非静态的成员变量，那么此方法就不能定义为静态的，非静态的方法中可以使用静态的成员变量。

static修饰成员方法

修饰的成员方法也称为类方法，可以直接使用类名访问。
在静态的方法中只能访问静态的成员变量，非静态的方法中可以使用静态的成员变量。

3、final 关键字

用于修饰类，方法，参数，成员变量(修饰后变常量)
·final 修饰的类是不能被继承的。所以不能修饰抽象类。例如 java中String类(String类是由final修饰的)
·final修饰的方法不能被重写
·final修饰方法的参数，参数值在方法中不能被改变的。
·final修饰的成员变量值不能改变，因此称为常量
情况1：在类定义时，值就已经确定并且直接赋值，复制后不能改变，建议用static去修饰final
情况2：在类定义时，值不明确，必须在创建对象后，在构造方法对其进行赋值，每个对象中拥有一个常量

八、代码块

在类中声明的一个没有名字的代码块
代码块分为：
实例代码块：在每次创建对象时执行
静态代码块：在类被加载时自动执行

九、包

项目越写越大，用到的类越来越多，会出现同名类，因此java中有 “包” 机制来管理类

作用

按照不同功能管理类
避免类重名
控制访问权限

包的命名与如何创建多级包

包目前至少三级
第一级项目类型如com org gov edu
第二级公司名字如baidu sun huawei
第三级项目名字如oa cms erp
第四级功能模块如web service dao config

十、访问权限修饰符

访问权限修饰可以修饰类、成员变量、成员方法、内部类。
public：公共权限，在任何地方都可以访问到
protected：受保护权限，在本类中，同包的其他类中可以访问到，还可以在其他包中的子类访问
(什么都不写)：默认权限，在本类中，同包的其他类中可以访问到
private：私有权限，在本类中可以访问到

十一、封装

封装的概念：

将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是
通过该类提供的方法来实现对隐藏信息的操作和访问。

封装的好处

通过特定的方法访问
隐藏类的信息
方便加入控制语句
方便修改实现

具体表现

使用不同的访问权限

public class Demo
{
	private String name;   //将类的成员变量访问权限设置为私有
	
	public String getName ()
	{ 
		return 	name;
	}    
	
	public void setName(String name)
	{
		this.name = name;
	}
}

十二、继承

1.继承的概念

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么，多个类中无需再定义这些属性和行为，只需要和抽取出来的类构成继承关系。

2.继承的好处

继承的出现减少了代码冗余，提高了代码的复用性。
继承的出现，更有利于功能的扩展。
继承的出现让类与类之间产生了is-a的关系，为多态的使用提供了前提。

3.何时使用继承

符合is-a关系的设计,可以使用继承例如：猫是动物、狗是动物

4.继承的语法

通过 extends关键字，可以声明一个类B继承另外一个类A，定义格式如下：

[修饰符] class 类A 
{
	...
}
[修饰符] class 类B extends 类A 
{
	 ...
}

类B，称为子类/派生类；类A，称为父类/基类

5.继承性的细节

子类会继承父类所有的实例变量和实例方法
子类不能直接访问父类中私有的(private)的成员变量和方法
在Java 中，继承的关键字用的是“extends”，表示子类是对父类的扩展
Java支持多层继承(继承体系)
一个父类可以同时拥有多个子类
Java只支持单继承，不支持多重继承

6.Object类

类 java.lang.Object,是类层次结构的根类，即所有其它类的父类。每个类都使用 Object作为超类。
当一个类没有显示的继承其他类时,默认继承Object类。

7.方法的重写

当父类的方法功能实现不能满足子类需求时,可以对方法进行重写( override). 子类可以对从父类中继承来的方法进行改造，在程序执行时，子类的方法
将覆盖父类的方法。也称为方法的覆盖。
注意：构造方法,静态方法不能重写,成员变量不存在重写

方法重写的规则

子类重写的方法必须和父类被重写的方法名称,参数列表相同。
子类重写的方法的返回值类型与父类保存一致。
子类重写的方法使用的访问权限不能小于父类被重写方法的访问权限。
注意：① 父类私有方法不能重写 ② 跨包的父类默认权限的方法也不能重写
子类方法抛出的异常不能大于父类被重写方法的异常

@Override

@Override是java中定义的注解标签,用来进行标记
写在方法上面，表示此方法是从父类重写而来,用来检测是不是满足重写方法的要求。这个注解就算不写，只要格式满足要求，也是正确的方法覆盖重写。建议保留，这样编译器可以帮助我们检查格式，另外也可以让阅读源代码的程序员清晰的知道这是一个重写的方法。

super关键字

在Java类中使用super来调用父类中的指定操作：

super可用于访问父类中定义的属性
super可用于调用父类中定义的成员方法
super可用于在子类构造器中调用父类的构造器
注意：
尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员
super的追溯不仅限于直接父类还可以是父类的父类
super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

误区: 不要把super误认为是父类对象,在创建子类对象时,不会创建父类对象. 只会将父类中的信息加载到子类对象中存储.

8.继承中的构造方法

子类继承父类时，不会继承父类的构造方法。只能通过“super(形参列表)”的方式调用父类指定的构造方法。
规定super(形参列表)，必须声明在构造器的首行。
如果在子类构造器的首行没有显示调用super(形参列表)，则子类此构造器默认调用super()，即调用父类中空参的构造器。
这么做是为了保证先对父类成员进行初始化。

开发中常见错误：

如果子类构造器中既未显式调用父类或本类的构造器，且父类中又没有空参
的构造器，则编译出错。

十三、抽象类

1.抽象方法

抽象方法是一种特殊的方法：它只有声明，而没有具体的实现。抽象方法必须用abstract关键字进行修饰。

如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类
抽象类除了不能实例化对象之外，类的其它功能依然存在，成员变量、成员方法和构造方法。
用abstract修饰的类就是抽象类。如果某个类中包含有抽象方法，那么该类就必须定义成抽象类。

特点:

抽象类不能被实例化，但可以有构造方法,因为抽象类中含有无具体实现的方法，所以不能用抽象类创建对象。
抽象类只能用作基类，表示的是一种继承关系。继承抽象类的非抽象类必须实现其中的所有抽象方法，而已实现方法的参数、返回值要和抽象类中的方法一样。否则，该类也必须声明为抽象类。

使用关键字abstract定义抽象类，一般语法：

[访问权限] abstract class 类名 
{
	成员列表
}

public abstract class Shapes 
{ 
	public abstract void draw();
}

抽象类，抽象方法，在软件开发过程中都是设计层面的概念。也就是说，设计人员会设计出抽象类，抽象方法，程序员都是来继承这些抽象类并覆盖抽象方法，实现具体功能。

十四、多态

父类引用指向子类对象，从而产生多种形态，如Animal dog = new Dog(); Animal cat = new Cat(); 同一种事物，在不同时刻表现不同状态
二者存在直接或者间接的继承关系时，父类引用指向子类的对象，即形成多态。

当编译期类型是父类，运行期类型是子类时，被称为父类引用指向子类对象

class  Animal
{
	…… 
}
class Cat  extends Animal
{ 
	……
}
class Dog extends Animal 
{ 
	……
}
Animal c = new Cat()  //Animal 的引用指向Cat的对象
Animal d = new Dog()  //Animal 的引用指向Dog的对象

向上转型

class Animal
{
	void eat()
	{
	}
}
class Cat extends Animal
{ 
	void eat() 
	{ 
		System.out.println("狗吃骨头");
	}
}      
………
Animal x=new Cat()  //向上造型，Cat对象提升到Animal对象
x.eat()   //在编译奇迹只能调用父类中定义的方法, 如果子类重写了父类方法,那么运行时调用子类重写的方法

多态的好处：提高代码的扩展性

class  Animal
{ 
	void eat() 
	{  
	}
}
class  Cat extends Animal
{ 
	void eat() 
	{  
	}
}
class Dog extends Animal
{ 
	void eat()
	{    
	}
}
//方法的形式参数类型是父类类型，而传递的实际参数可以是任意子类的对象
method(Animal  animal)
{  
	animal.eat();                
}

多态环境下对成员方法的调用

class  Animal
{
	void show() 
	{ 
		System.out.println(“Anmial"); 
	}
}
class Cat  extends Animal
{ 
	void show() 
	{ 
		System.out.println(“cat");
	}
}
……
Animal x = new Cat() 
x.show() //调用的是子类中的方法
//简单的说：编译看左边，运行看右边。

多态环境下对静态成员方法的调用

class  Animal
{
	static  void show() 
	{ 
		System.out.println(“Animal"); 
	}
}
class Cat extends Animal 
{ 
	static  void show() 
	{ 
		System.out.println(“Cat");
	}
}
…….
Animal x = new Cat() 
x.show() //调用的是动物类中的静态成员方法。
//简单的说：编译和运行都看左边。

多态环境下对成员变量的调用

class Animal
{ 
	int num = 3;
}
class Cat  extends Animal 
{ 
	int  num = 4;
}
……
Animal x = new Cat() 
x.num; //调用的是动物类中的成员变量。
/*
简单的说：编译和运行都看等号左边。
注意：变量不存在被子类覆写这一说法，只有方法存在覆写。
*/

向下转型
父类引用仅能访问父类所声明的属性和方法，不能访问子类独有的属性
和方法。
向下转型的作用是：为了使用子类中的特有方法。

class Animal
{ 
	void eat()
	{ 
	}
}
class Cat extendsAnimal
{
	void look() 
	{
		System.out.println("看家");
	}
}      
………
Animal x=new Cat()
x.look();//编译报错,Animal类型中没有look方法
Cat  m=(Cat)x;  //需要向下转型,转为Cat类型
m.eat() ;
m.look();//子父类中的方法都可以使用

十五、接口

接口是计算机领域的名词，表示一种功能的定义
例如：USB接口定义USB接口的规范，让其他设备去实现
从本质上讲，接口可以看做是一种特殊的抽象类，里面也包含抽象方法。
接口不能被创建对象，不能被其它类实现，不能重写抽象方法，主要也是用来定义功能的。
接口在jdk8后可以定义静态常量，抽象方法，静态方法，默认方法。

接口的定义：使用interface关键字修饰接口

[访问修饰符]  interface  接口名称  [extends 其他的接口名1,….其他的接口名n] 
{ 
	// 声明常量   抽象方法  静态方法   默认方法
}

接口的使用：类使用implements关键字实现接口。在类声明中，Implements 关键字放在class声明后面。

[访问修饰符] class 类名 implements 接口名1，接口名2……
{ 
}

结合继承：

[访问修饰符] class 类名 extends 父类名 implements 接口名1，接口名2……
{ 
}

接口的特性
– 接口是隐式抽象的，主要用来定义功能.
– 接口中可以定义静态常量,抽象方法,静态方法,默认方法.
– 一个接口能继承其它多个接口.
– 接口不能实例化对象.
– 接口是要被类实现,一个接口可以被多个实现
– 当类实现接口的时候，类要实现接口中所有的抽象方法,否则，该类必须声明为抽象的类.
– 接口与实现类之间存在多态性