JavaSe学习笔记 day03（面向对象一）

概述

一 学习面向对象的三条主线：
1）Java类及类的成员：属性、方法、构造器；代码块、内部类

2）面向对象的三大特征：封装性、继承性、多态性、(抽象性)

3）其它关键字：this、super、static、final、abstract、interface、package、import等

二、“人把大象装进冰箱”

1）.面向过程：强调的是功能行为，以函数为最小单位，考虑怎么做。

2）面向对象：强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。

三、面向对象的两个要素：
类：对一类事物的描述，是抽象的、概念上的定义
对象：是实际存在的该类事物的每个个体，因而也称为实例(instance)，对象是由类派生出来的（new 出来的）。

可以理解为：类 = 抽象概念的人；
对象 = 实实在在的某个人 面向对象程序设计的重点是类的设计
类的设计，其实就是类的成员的设计

四 类的成员 ：属性和方法
Field = 属性 = 成员变量
Method = （成员）方法 = 函数

五 面向对象的落地实现：
1.创建一个类并提供必要的属性和方法
2.通过该类创建对象。（new 对象）
3.调用属性和方法 ： 对象名.属性名 对象名.方法名

方法

方法其实就是若干语句的功能集合
参数：就是进入方法的数据
返回值：从方法中出来的数据

格式：
修饰符 返回值类型 方法名称（参数类型 参数名称，....）{
方法体
return 返回值；
}

修饰符：现阶段的固定写法，public、缺省、protected、private

返回值类型：也就是方法最终产生的数据结果是什么类型

方法名称：方法的名字，规则和变量一样

参数类型：进入方法的数据是什么类型

参数名称：进入方法的数据对应的变量名称

注意：参数如果有多个，使用逗号进行分割

方法体：方法需要做的事情，若干行代码

return：两个作用，第一停止当前方法，第二将后面的返回值还给调用处

返回值：也就是方法执行后最终产生的数据结果

注意：return后面的“返回值”，必须和方法名称前面的“返回值类型”，保持一致，return关键字后面不可以声明执行语句。

作用：1.返回数据 2.结束方法

如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用return关键字来返回指定类型的变量或常量：“return
数据”。如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。

方法的三种调用：

1.单独调用：方法名称（参数）；

2.打印调用：System.out.printl(方法名称(参数))；

3.赋值调用：数据类型 变量名称 = 方法名称（参数）；

方法的重载

1.定义：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。

“两同一不同”:同一个类、相同方法名

参数列表不同：参数个数不同，参数类型不同

2.举例： Arrays类中重载的sort() / binarySearch()

3.判断是否是重载：跟方法的权限修饰符、返回值类型、形参变量名、方法体都没有关系！

4.在通过对象调用方法时，如何确定某一个指定的方法： 方法名 —> 参数列表

匿名对象：

匿名对象：没有名字的对象

创建对象时，只有创建对象的语句，却没有把对象地址赋值给某个变量。虽然是创建对象的简化写法，但是应用场景非常有限

匿名对象的特点：

1、只能调用一次

2、给引用数据类型的变量赋值只能赋值该类型的对象

作用：往往作为实参进行传递

属性

一、变量的分类：

按照数据类型分 ：基本数据类型 vs 引用数据类型

按照位置分 ： 局部变量 vs 成员变量（属性）

语法格式
修饰符  数据类型  属性名 = 初始化值 ; 

二、局部变量和成员变量的共同点：

1.都是先声明后使用

2.声明的格式都是一样的

3.都有作用域

三、局部变量和成员变量的不同点：

1.默认值：

属性：

基本数据类型： byte,short,int,long -> 0
float,double -> 0.0
char -> \u0000
boolean -> false
引用数据类型 ：类，接口，数组 -> null
局部变量 ：没有默认值

属性赋值的方式和顺序： 1.默认值 2.显示赋值 3.构造器赋值 4.对象名.属性名、对象名.方法名 顺序 ： 1-> 2 -> 3 -> 4

面向对象的特征——封装和隐藏

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

Java中通过将数据声明为私有的(private)，再提供公共的（public）方法:getXxx()和setXxx()实现对该属性的操作，以实现下述目的：

隐藏一个类中不需要对外提供的实现细节；使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；便于修改，增强代码的可维护性；

一 为什么要使用封装性：

当我们创建对象以后，就可以通过对象名.属性名的方式对属性进行赋值。这种方式默认只能对内容的类型和范围进行约束。但是在实际开发中往往我们还会有更多的限制条件，但这些限制条件无法在属性的声明处加以限制。所以我们采取如下方式

1.使用private修饰属性，这样就不能直接再使用对象名.属性名的方式进行赋值了

2.提供公共的方法给属性赋值和获取属性的值，这样可以在方法中对赋值的内容加以限制。

二 封装性的体现（狭义上）

1.私有化属性，提供公共的set/get方法

三 封装性的体现（广义上）

1.四种权限修饰符 ：private 缺省的   protected  public

2.可以使用四种权限修饰符修饰 ： 属性，方法，构造器，内部类。

3.类只能使用public和缺省的修饰。

四注意 ： set/get方法就是普通方法。如果开心可以起任意名字

class Animal{
String name;
private int age;
private int legs;//腿的个数

//对属性的设置
public void setLegs(int l){
    if(l >= 0 && l % 2 == 0){
        legs = l;
    }else{
        legs = 0;
    }
}
//对属性的获取
public int getLegs(){
    return legs;
}
}

五 四种访问权限修饰符

构造器

一、构造器（Construcotor） - 构造方法 :

作用 ： 1.创建对象    2.对对象进行初始化

格式：
		权限修饰符   类名 （形参列表）{
			执行语句;
		}

二、说明：
1.如果在类中没有显示的提供构造器，那么系统会默认提供一个空参的构造器。
那么我们创建对象时调用的就是这个默认空参构造器。
2.如果在类中显示的提供了构造器，那么系统将不再提供默认的空参构造器。
3.构造器可以有多个，彼此之间构成重载

三、总结 ： 创建对象必调构造器
构造器的特点 ：同一个对象只能调用一次。
构造器使用的场景 ：1.创建对象 2.给对象进行初始化 3.在对象中只执行一次的代码放在构造器中。

JavaBeen

JavaBean : JavaBean是一种Java语言写成的可重用组件其就是一个普通的类，用来存储数据的。但是拥有以下面的特点。

 特点 ：
	1.类是公共的
	2.有一个无参的公共的构造器
	3.有属性，且有对应的get、set方法

MVC设计模式

MVC是常用的设计模式之一，将整个程序分为三个层次：视图模型层、控制器层与数据模型层。这种将程序输入输出、数据处理以及数据的展示分离开来的设计模式使程序结构变得灵活而且清晰，同时也描述了程序各个对象间的通信方式，降低了程序的耦合性。

模型层：model 主要处理数据

数据对象封装 model.bean/domain

数据库操作类 model.dao

数据库 model.db

控制层：controller 处理业务逻辑

应用界面相关 controller.activity

存放fragment controller.fragment

显示列表的适配器 controller.adapter

服务相关的 controller.service

抽取的基类controller.base

视图层：view 显示数据

相关工具类 view.utils
自定义 viwe.ui

关键字

this关键字

1.关键字 ：this
this用来表示当前对象。
this可以调用属性，方法，构造器。

2.this调用属性：
在构造器和方法中我们可以直接调用属性，往往会省略"this."。但是局部变量名和属性名一样时。那么必须使用"this."来区分属性和局部变量。

3.this调用方法：
在同一个类中方法之间可以相互调用。在调用的时候可以省略 “this.”。

4.this调用构造器：
格式 ： this(形参列表)
作用 ：调用本类中的其它构造器

说明：
1.this(形参列表)必须在构造器的首行。
2.在同一个构造器中最多只能有一个this(形参列表)
3.如果有N个构造器那么最多只能有N-1个this(形参列表)

package关键字

关键字 (package) : Java为了实现对类进行统一的管理和划分所以有了包的概念。

说明：
1.包名 ：包名应该全部小写 - xxxyyyzzz
2.如何命名 ： 机构的类型（com.org.edu） + 机构的名称 + 项目名 + 模块名
3.每"."一下就是一层目录
4.同一个包中的类名不能相同，不同包中的类名可以相同。
5.package com.atguigu.java;必须声明在源文件的首行
6.在源文件中加上package com.atguigu.java，当我们进行编译时就能将生成的字节码文件放到对应的包中。

Import

import:导入

1.在源文件中显式的使用import结构导入指定包下的类、接口

2.声明在包的声明和类的声明之间

3.如果需要导入多个结构，则并列写出即可

4.可以使用"xxx.*"的方式，表示可以导入xxx包下的所有结构

5.如果使用的类或接口是java.lang包下定义的，则可以省略import结构

6.如果使用的类或接口是本包下定义的，则可以省略import结构

7.如果在源文件中，使用了不同包下的同名的类，则必须至少有一个类需要以全类名的方式显示。

8.使用"xxx.*"方式表明可以调用xxx包下的所有结构。但是如果使用的是xxx子包下的结构，则仍需要显式导入

9.import static:导入指定类或接口中的静态结构:属性或方法。

super关键字

1.关键字：super
super 调用 父类中的属性，方法，构造器

2.super调用父类中的属性和方法
在子类的构造器和方法中可以使用“super.”调用父类中的属性和方法,但是我们可以省略“super”。如果子类和父类中的属性名相同或则子类重写了父类中的方法，那么必须使用“super.”来区分调用的是子类的还是父类的。

“this.“先从子类中查找，如果有就调用子类中的，如果子类没有再调用父类的

”super."直接从父类中查找，如果父类中没有直接报错

注意：只要调用父类中的属性和方法全部就上”super.“。

3.super调用构造器
作用：调用父类的构造器
格式：super（形参列表）
说明：

1.super（形参列表）必须放在构造器的首行
2.super（形参列表）和this（形参列表）同时只能有一个。
3.在子类的构造器中没有使用super（形列表）或则this（形参列表）则默认使用super（）

4.总结 ：创建子类对象必调父类的构造器。
一个类中如果有N个构造器，最多只能有N-1个this(形参列表)

报错 Implicit super constructor Person() is undefined. Must explicitly invoke another constructor
解决的方式一：
父类提供一个空参构造器
解决的方式二：
显示调用父类中的其它构造器
通过调用父类构造器给父类中的属性赋值。

return关键字

在有返回值的方法中 ： 1.返回数据 2.结束方法

在没有返回值的方法中 ： 1.结束方法

方法如果有返回值类型，那么无论如何都必须返回数据，否则编译会出错。

final关键字

final修饰类：类不能被继承。比如String

final修饰方法：final修饰的方法不能被重写

final修饰属性 ：final修饰的属性的值不能被修改，final修饰的属性必须得赋值。

final修饰的属性赋值的方式 ： 显示赋值，代码块赋值,构造器赋值

static关键字

1.概述
当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上的对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象，其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存空间里只有一份，例如所有的中国人都有个国家名称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中都单独分配一个用于代表国家名称的变量。

2.static内存分析
当我们创建Person对象时，首先会去方法区查找是否有Person的类信息
2.1 如果方法区中没有Person类信息，那么便会进行类加载（JVM会把对应的字节码文件加载到方法区中）
2.2 在加载类信息时会为类变量开辟内存区域。
2.3 如果方法区中已经存在Person类信息那么直接创建对象

3 static可以修饰：属性，方法，代码块，内部类

3.1 static修饰属性（类变量）：
1）同一个类创建的多个对象，每个对象单独拥有一份实例变量，共同拥有一份类变量。
2）同一个类多个对象中某个对象对类变量进行修改后，其它的对象看到的是修改后的值。
3）类变量是随着类的加载而加载的（类加载加载一次）。实例变量是随着对象的创建而加载的。
4）调用类变量的方式 ： 类名.类变量名 对象名.类变量

3.2.static修饰方法（静态方法）：
1 ）静态方法是随着类的加载而加载的。
2 ）静态方法中不能调用实例变量和非静态方法 (原因 ：因为加载时机不同。类加载的时候对象还没有呢)
3）非静态方法中可以调用类变量和静态方法
4）静态方法中不能使用"this"和"super"关键字

4 static使用场景：
4.1 static修饰属性 ：
1）多个对象需共同拥有该属性时那么使用static修饰
2）常量 ： public static final double PI = 3.14159265358979323846;
4.2 static修饰方法：
1）工具类中的方法都是静态方法
2）有时为了调用类变量方法也会定义成静态方法。
5.特点
1）随着类的加载而加载
2）优先于对象存在
3）修饰的成员，被所有对象所共享
4）访问权限允许时，可不创建对象，直接被类调用

abstract关键字

1.abstract可以修饰：方法和类

2.abstract修饰类（抽象类）：

1）抽象类不能被实例化

2）抽象类中一定有构造器，便于子类实例化时调用（涉及：子类对象实例化的全过程）
开发中，都会提供抽象类的子类，让子类对象实例化，完成相关的操作

3）非抽象子类继承抽象类后必须重写抽象父类中的所有抽象方法

4）如果非抽象子类不想重写抽象父类中的抽象方法，那么该子类也需要变成抽象子类。

5）抽象子类可以重写抽象父类中的抽象方法，如果直接抽象父类重写了间接抽象父类中的抽象方法那么非抽象子类就不需要再重写该抽象方法

3.抽象类中不是必须有抽象方法的。abstract修饰方法（抽象方法）：

1）抽象方法没有方法体

2）抽象方法所在的类必须为抽象类

4.注意：

1）抽象类不能和这些关键词同时使用： final,private,static

2）abstract不能用来修饰：属性、构造器等结构

Java中主要包的介绍

java.lang ------ 包含一些Java语言的核心类，如String、Math、Integer、System、Thread，提供常用功能

java.net ------ 包含执行与网络相关的操作的类和接口

java.io ------ 包含能够提供多种输入/输出功能的类

java.util ------ 包含一些实用工具类，如定义系统特性、接口的集合框架类、使用与日期日历相关的函数

java.text ------ 包含了一些java格式化相关的类

java.sql ------ 包含了java进行JDBC数据库编程的相关类/接口

java.awt ------ 包含了构成抽象窗口工具集（abstract window toolkits)的多个类，这些类被用来构建和管理应用程序的图形用户界面（GUI）

面向对象特征——继承性

一、继承性的好处：

① 减少了代码的冗余，提高了代码的复用性

② 便于功能的扩展

③ 为之后多态性的使用，提供了前提

二、继承性的格式： class A extends B{}

A:子类、派生类、subclass

B:父类、超类、基类、superclass

2.1体现：一旦子类A继承父类B以后，子类A中就获取了父类B中声明的所有的属性和方法。特别的，父类中声明为private的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只有因为封装性的影响，使得子类不能直接调用父类的结构而已。

2.2 子类继承父类以后，还可以声明自己特有的属性或方法：实现功能的拓展。子类和父类的关系，不同于子集和集合的关系。

extends：延展、扩展

三、Java中关于继承性的规定：

1.一个类可以被多个子类继承。

2.Java中类的单继承性：一个类只能有一个父类

3.子父类是相对的概念。

4.子类直接继承的父类，称为：直接父类。间接继承的父类称为：间接父类

5.子类继承父类以后，就获取了直接父类以及所有间接父类中声明的属性和方法

四、 1.如果我们没有显式的声明一个类的父类的话，则此类继承于java.lang.Object类

2.所有的java类（除java.lang.Object类之外）都直接或间接的继承于java.lang.Object类

3.意味着，所有的java类具有java.lang.Object类声明的功能。

方法的重写

方法的重写 ： 子类可以对父类中的方法进行覆盖。
1.说明：
当子类重写了父类中的方法后。那么再通过子类对象调用相同的方法，实际上调用的是子类重写父类的方法。
2. 使用方法的重写的场景 ： 如果子类对父类中的方法不满意那么可以考虑使用方法的重写
3. 重写的规则

	1）子类重写的方法的权限修饰符 不小于 父类被重写方法的权限修饰符。
	2）子类重写的方法的方法名和形参列表必须和父类被重写方法的相同。
	3）父类被重写的方法的返回值类型		子类重写的方法的返回值类型
	    			void					   void
	    		基本数据类型				对应的基本数据类型
	    		引用数据类型				对应的类型及子类的类型
	 		（object <- Number <- Integer）

4.子类方法抛出的异常不能大于父类被重写方法的异常
注意：

	1.父类中被private修饰的方法，子类不能重写。
	2.子类和父类中相同的方法要么同时加static(不是方法的重写)要么同时不加static（方法的重写）