接口

一.语法：
public interface 接口名{
public void foo()；
}

二.特征
1.接口不可被实列化
2.实现类必须实现接口所有方法
3.实现类可以实现多个接口
4.接口中的变量都是静态常量，默认是public修饰
5.接口中不能有构造方法
6.接口中的方法全是public修饰的抽象方法

三.步骤：
1.编写接口--interface
2.实现接口--implements
3.使用接口

四.面向接口编程
1.关系实现类有何能力，而不关心实现细节
2.面向接口的约定，而不考虑接口的具体实现
3.程序设计是面向接口的约而不考虑具体实现

五.接口比抽象类的好处
1.可以被多继承
2.设计和实现完全分离
3.更自然使用多态
4.更容易搭建程序框架
5.更容易实现

多态

多态
一.概念
1.同一种事物，由于条件不同，产生结果不同
2.同一引用类型，使用不同的实列而执行不同的操作
父类引用子类对象

二.步骤
1.编写父类
2.编写子类，子类重用父类方法
3.运行时，使用父类的类型，子类的对象

三.类型转换
1.向上转型（自动类型转换）
父类 a=new 子类（）；
2.向下转型（强制类型转换）--发生在向上转型的基础上
父类 a=new 子类（）；
子类 b=(父类）a;

四.实现多态的两种方式
1.使用父类作为方法形参实现多态
2.使用父类作为方法返回值实现多态

五.instanceof运算符
对象 instanceof 类或接口
instanceof通常和强制类型转换结合使用

内部类
1.根据位置的不同Java的内部类分为：静态内部类、成员内部类、局部内部类、匿名内部类
2.任何内部类都编译成独立的class文件
3.最大的作用：封装
4.匿名类可以封装内部概念

静态内部类
使用static修饰，声明在类中
静态内部类中可以访问外部类的静态成员
列：public class Foo（）{ 外部调用：
static class Woo{}-----------Foo.woo=new Foo.woo();
}
静态内部类的作用域和静态的变量一样，都是在类加载的时候就有了

成员内部类
声明在类中，不使用static，具有类的成员特征，也就是必须有类的实列才能创建

类的实列，内部类实列可以访问外部类的成员
列：public class Yoo{ 外部调用：
class MOO{}----------Moo moo=Yoo.new Moo();
}

局部内部类
把类声明在方法中，就是局部内部类，作用域类似局部变量
局部内部类的方法中，如要访问外部类的属性，则必须是final修饰的常量

匿名内部类
1.可以使用在任何地方，就像一般语句
2.语法像创建对象------Date date=new Date{//....}
3.匿名类是对原类的继承，同时创建了实列，{}就是继承以后的类体
4.类体中可以使用所有类的语法
5.匿名类不能写构造方法
6.匿名类可以从抽象类或接口继承，必须提供抽象方法的实现

面向对象三个特征：封装、继承、多态
封装：
语法：属性私有化（private）、提供相对应的get/set 的方法进行访问(public)、

在set/get的方法中对属性的数据 做相对应的业务逻辑的判断
思想：封装外面的程序不能直接访问本类的属性，需要通过本类提供的方法间

接访问本类的属性，从而提高代码的安全性。
涉及到的其他的知识点：
构造方法：用来描述对象创建过程，可以通过构造方法快速创建对象。
this关键字：代表本类对象，调用本类的属性、方法、构造方法。
方法重载：方法名相同，参数列表不相同
继承：
语法：子类 extends 父类
思想: 多个类所描述的有共同的特征或行为，就可以将这些
类中共同的部分抽取出来建立他们的父类。
继承的好处：子类共用父类的代码，提高了代码的重用性;代码
后期扩展和维护，只需添加对应的子类即可。
涉及到的其他的知识点：
super关键字：代表父类的对象，调用父类的属性、方法、构造方法。
abstract关键字：抽象，修饰类、修饰方法。
static关键字：静态，修饰属性、方法、代码块、内部类
final关键字：最终，修饰属性、方法、类
方法重写：方法名相同，参数列表相同，返回值类型相同，

修饰符大于或等于父类的访问修饰符
多态：
语法：父类 对象名=new 子类();
思想：父类型的引用可以指向内存中的子类对象的内存空间，
就可以方便在设计方法的参数和返回值类型的时候，可以
设计成父类对象，这样的方法在实现时比较简洁，在后期
进行扩展时，方法比较容易。
在代码中，多态的使用更多的是父类引用指向子类对象,
会自动类型转换（向上转型）,但是有时候也需要调用子类
中自己的东西，这个时候就需要还原子类，叫强制类型转换
（向下转型），转的时候要先使用instanceof运算符做类型的
判断。

1.final关键字可以修饰属性、方法、类
2.final关键字修饰的类不能被继承，如：String类
3.final关键字修饰方法，不能在被子类重写
4.final关键字修饰的变量，初始化以后值不能在发生改变
在Java中使用static和final关键字共同修饰的变量称为常量，常量名为全大写
如：public static final int AGE=20；
final修饰的引用类型的变量，引用地址不能发生改变，但是值限定的第一层，

引用数据类型的属性值是可以发生改变的

1.abstract关键字表示抽象的意思，可以用来修饰方法、类
修饰的类叫抽象类，修饰的方法叫抽象方法
2.abstract关键字修饰类
访问修饰符 abstract class 类名（）{}
抽象类用来表示一些抽象的概念
特点：a.抽象类不能被实列化
b.抽象类可以有属性、方法、构造方法，都是用来给子类继承、调用
c.抽象类中的方法不一定是抽象方法，抽象方法必须在抽象类中
3.abstract关键字修饰方法
访问修饰符 abstract 返回值类型 方法名（参数列表）；
抽象方法不需要自己实现，由子类实现
特点：a.抽象方法没有方法体
b.抽象方法必须出现在抽象类中
c.一个类继承抽象类后必须实现里面所有的抽象方法
4.抽象类可以继承抽象类

方法重写
1.方法名相同
2.参数列表相同
3.返回值相同或其子类
4.访问修饰符不能严于符类
注：@override 检测方法重写是否正确
构造方法不能被重写

八.方法重写与方法重载的区别

位置 方法名 参数列表 返回值 访问权限
方法重写 子类 相同 相同 相同或其子类 不能严于父类
方法重载 本类 相同 不同 无关 无关

1.在创建类之前，检查类是否已加载（检查硬盘上的class文件，是否已加载到内存中），

如果没有加载就先加载父类文件，再加载本类的文件
Java使用的加载策略：懒惰式加载（按需要加载），用到的时候加载，只加载一次
2.分配对象空间递归分配所有父类和子类的属性空间
属性会自动初始化为“0”值
3.给属性赋值
4.调用父类构造方法（默认调用父类的无参构造方法）
5.调用本类构造方法

访问修饰符 本类 同包 子类 其他
private y n n n
默认 y y n n
protected y y y n
public y y y y

注：在类中，只能有一个被public修饰的class

y:yes n:no

一.继承的优点
1.提高代码的可重用性（继承之后子类共用父类代码）
2.提高代码的可维护性（后期代码增加、删除）

二.继承的前提
子类和父类之间必须要满足子类is a 父类的逻辑关系才能有继承

三.步骤/语法
1.将多个类中共有的属性、方法提取出来建立父类
访问修饰符 class 父类{

}
2.在子类后面使用extends关键字完成继承
访问修饰符 class 子类 extends 父类{

}
3.在子类中可以调用父类的代码--使用super关键字代表父类对象
a.访问父类构造方法
super（）；--在子类构造方法中调用且必须是第一据，与this互斥
super（参数列表）；
b.访问父类属性--前提为属性不能私有
super.name；
c.访问父类的方法
super.print（）；

注：1.父类中的构造方法不会被继承，但可以被调用
2.子类与父类不在同包中，使用默认访问修饰权限的成员不能被继承
3.private成员不能被继承

四.多重继承的关系的初始化顺序
父类属性-->父类构造方法-->子类属性-->子类构造方法

面对对象设计和开发程序的好处
1.交流更加流畅
2.提高设计和开发效率
面向对象设计的过程
1.发现类
2.发现类的属性
3.发现类的方法

1.static修饰的资源属于类级别的资源，静态的资源，对于类所有实列共享的资源
2.static关键字可以用来修饰属性、方法、代码块、内部类
a.static修饰属性：
static修饰的属性属于对类所有实列共享的资源
访问静态的属性：类名.属性名（）；
b.static丝素方法：
static修饰的方法属于静态方法，可以直接类名.方法名（）进行调用，一般是把静态方法作为

工具方法静态方法中不能调用对象的资源（对象、属性、对象方法）
c.static修饰代码块
在类加载的时候执行，因为类只加载一次，所以static的代码块也只执行一次，一般是

使用static代码块来加载一些静态资源如配置文件
static{ {
//静态代码块 //代码块，在创建对象的时候执行
} }
3.static修饰的资源，在类加载期间执行
4.

static、非private修饰 非static、非private修饰

属性 类属性、类变量 实列属性、实列变量

方法 类方法 实列方法

类名.属性（）
调用方式 类名.方法（） 对象.属性（）
对象.属性（） 对象.方法（）
对象.方法（）

归属 类 单个对象（）

封装

1.概念：将类的某些信息隐藏在类的内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问、
2.好处：a.只能通过规定的方法访问数据
b.方法修改实现
c.隐藏类的实现细节
d.方便加入控制语句
3.使用步骤：
a.修改属性的可见性----设为private
d.创建公有的get/set方法----用于属性的读写
c.在get/set方法中加入属性控制语句---对属性值的合法进行判断

this关键字

1.调用属性：this.health=100；
2.调用方法：this.print（）；
3.调用构造方法：
a.this（）--如果使用，必须是构造方法中的第一条语句
b.this（“小黑”，100,100，“女”）

1.构造方法是用来描述对象创建的过程
构造方法在对象创建的过程中被使用
2.语法：
访问修饰符 （无返回值类型） 构造方法名（=类名）{
//初始化代码
}
3.如果没有写构造方法，系统会自动提供一个无参的构造方法；
如果类中出现了构造方法，系统不会提供默认的无参的构造方法；
4.方法重载
a.方法名相同
b.参数不同
c.与返回值，访问修饰符无关
5.方法签名
a.语法： 方法签名=方法名+参数列表 如 add（int，int）
b.Java中不可能出现方法签名相同的两个方法

类图

1.好处：a.用于分析和设计类
b.直观容易理解

2. dog 类名
+ name：String public 属性名：类型
+health：int public 属性名：类型
-love：int private 属性名：类型
+Print（）：void public 方法名：返回值类型

StringBuffer

a.StringBuffer：String增强版
对字符串频繁修改（如字符串链接）时，使用StringBuffer类可以提高程序执行效率
b.StringBuffer声明
StringBuffer SB=newStringBuffer（）；-----创建空StringBuffer对象
StringBuffer SB=newStringBuffer（“aaa”）；------创建一个变量存储字符串aaa
c.StringBuffer使用
转为String类型：SB.toString（）；
追加字符串：SB.append（“**”）；
插入字符串：SB.insert（i，“**”）；

1.使用String对象存储字符串
String s="Helloword"
String s=new String();
String s=new String("Helloword")

2.String类位于包java.lang包中，具有丰富的方法
计算字符串的长度，比较字符串，连接字符串，提取字符串

3.字符串长度
语法：方法原理：public int length（）{}
调用方法：字符串标识符.length（）；

4.字符串比较
String类提供了equals（）方法，比较存储在两个字符对象内容是否一致（返回值boolean类型）

equals与==的区别
==：比较是否在同一内存空间或比较数字
equals：比较内容是否一致

5.字符串字母转换
使用equalslgnoerCase()方法--字符串比较时忽略大小写
使用toLouerCase()方法--返回字符串小写形式
使用toUpperCase（）方法--返回字符串大写形式

6.字符串连续
a.使用“+”
b.使用concat()方法
A.concat(B);
B字符串将连续到A字符串后面

7.字符串提取方法
a.搜索第一个出现的字符ch（或字符串value）
public int indexOf(int ch)
public int indexOf(String value)

b..搜索最后一个出现的字符ch（或字符串value）
public int lastindexOf(int ch)
public int lastindexOf(String value)

c.从指定位置寻找字符或字符串，返回下标
s.indexOf(寻找字符.指定位置)

8.判断字符串是否一指定格式结尾（返回boolean类型）
s.endsWith（字符串）
判断字符串是否一指定格式开头（返回boolean类型）
s.StartsWith（字符串）

9.常用的提取方法
a.public string substring(int index)
提取从位置开始的字符串部分--index
b.public String substring(int begininelex,int endindex)
提取begininelex之间的字符串部分
c.public String trim（）
返回一个前后不含任何空格的调用字符串副本

10.字符串拆分
String类提供了Split（）方法，将一个字符串分割为子字符串，结果作为字符串数组返回

成员变量和局部变量

1.变量声明的位置决定变量作用域
2.变量作用域确定可在程序中按变量名访问该变量的区域
3.成员变量：定义在类中的变量（类或其他类中可以调用）
4.局部变量：定义在方法中的变量（方法）
5.区别：a.作用域不同
局部变量的作用域仅限于定义它的方法
成员变量的作用域在整个类内部都是可见的
b.初始值不同
Java会给成员变量一个初始值
Java不会给局部变量赋予初始值
6.在同个方法中，不允许有同名局部变量
在不同方法中，可以有同名的局部变量
在同个类中，成员变量和局部变量同名时，局部变量具有更高的优先级

方法

一.定义类方法
语法： public 返回值类型 方法名（）{---步骤一：定义方法名和返回类型
//这里编写方法的主体---步骤二：编写方法体
}

二.方法返回值
1. 如果方法具有返回值，方法中必须使用关键字return返回该值，返回值类型为该返回值的类型
语法： return 表达式 ；
作用： 跳出方法，返回结果
2.如果方法没有返回值，返回值类型为void；

对象和类

一.对象的特征
1.属性--对象具有各种特征
2.每个对象的每个属性都有特定值
3.方法--对象执行的操作
4.对象：用来描述客观事物的一个实体，由一组属性和方法构成

二..类
类是模子，定义对象将会拥有的特征（属性）和行为（方法）
类是对象的类型--不同于int类型：具有方法

三.类和对象的关系
类是抽象的概念，仅仅是模板
对象是一个看得见摸得着的具体实体

四.如何创建对象和使用对象
使用对象的步骤
a.创建对象
类名 对象名=new 类名（）；
b.引用对象成员：使用“.”进行以下操作
引用类的属性：对象名.属性
引用类的方法：对象名.方法

Java（六）