javaday08
目录
Day08---面向对象. 1
1 抽象类. 1
1.1 概念. 1
1.2 特点. 1
1.3 入门案例. 1
2 抽象类的用法. 1
2.1 构造函数. 1
2.2 成员变量. 1
2.3 成员方法. 1
3 接口. 1
3.1 概念. 1
3.2 特点. 1
3.3 入门案例. 1
4 接口的用法. 1
4.1 构造方法. 1
4.2 成员变量. 1
4.3 成员方法. 1
4.4 测试. 1
5 总结. 1
6 程序设计. 1
7 设计模式. 1
7.1 单例设计模式概念. 1
7.2 源码剖析. 1
7.3 饿汉式. 1
7.4 懒汉式. 1
8 扩展. 1
8.1 abstract注意事项. 1
8.2 接口和抽象类的区别. 1
Day08---面向对象
1 抽象类
1.1 概念
Java中可以定义没有方法体的方法，该方法由其子类来具体的实现。
该没有方法体的方法我们称之为抽象方法。
含有抽象方法的类我们称之为抽象类。
抽象类可以理解为是一个只有方法声明没有方法体的特殊类。
abstract 修饰符 返回值 方法名(参数列表);
抽象的 class Animal{
抽象的 public void eat();//父类方法体提供了显得多余，那就不提供方法体，没有方法体的方法 -- 抽象方法
}
class Cat extends Animal{
@Override
public void eat(){
syso("猫吃鱼");
}
}
class Dog extends Animal {
}
1.2 特点
1、 通过java关键字abstract实现
2、 可以修饰方法或者类
3、 抽象类中可以没有抽象方法（由子类去实现）
4、 如果类中有抽象方法，那该类必须定义为一个抽象类
5、 子类继承了抽象类以后，要么还是一个抽象类，要么就把所有抽象方法都重写
6、 多用于多态中
7、 抽象类不可以被实例化（实例化就是new的过程）
1.3 入门案例
创建day08工程
创建cn.tedu.abstractdemo包
创建Test1_Abstract.java
package cn.tedu.abstractdemo;
//测试抽象类入门案例
public class Test1_Abstract {
public static void main(String[] args) {
//5、抽象类不能被实例化new
// Student s = new Student();
// s.eat();s.sleep();
//TODO 创建多态对象测试
Person p = new Teacher();//父类的引用指向子类的对象
//编译看左边，运行看右边
p.eat();
p.game();
p.sleep();
}
}
//创建抽象类
//3、如果一个 类中 包含抽象方法 -- 这个类必须是一个抽象类，用abstract修饰
abstract class Person{
//1、父类中的方法体没必要提供时，这个方法就是没有方法体的方法 叫 抽象方法
//2、用关键字abstract修饰抽象的
abstract public void eat();
abstract public void game();
public void sleep() {
System.out.println("睡觉");
}
}
//创建子类
//4、子类如果继承了抽象类，子类如果只不重写，或者只重写一部分，那子类仍然是抽象类
abstract class Student extends Person{
//TODO 重写eat()
public void eat() {
System.out.println("吃菜");
}
}
//4.1、子类如果继承了抽象类，要把所有抽象方法都重写 变成 普通子类
class Teacher extends Person{
public void eat() {
System.out.println("不吃");
}
public void game() {
System.out.println("不玩");
}
}
2 抽象类的用法
2.1 构造函数
常用于子类的实例化
package cn.tedu.abstractdemo;
//抽象类的用法
public class Test2_UseAbstract {
public static void main(String[] args) {
//TODO 创建多态对象测试
Animal a = new Dog();
}
}
//创建父类
abstract class Animal{
//TODO 抽象类提供构造方法：不是为了创建抽象类的对象(也不能创建)，而是为了创建子类对象
public Animal() {
System.out.println("构造方法");
}
}
//创建子类
class Dog extends Animal{
public Dog() {
super();//默认就有
}
}
2.2 成员变量
既可以有变量，也可以有常量。
package cn.tedu.abstractdemo;
//抽象类的用法
public class Test2_UseAbstract {
public static void main(String[] args) {
//TODO 创建多态对象测试
Animal a = new Dog();
}
}
//创建父类
abstract class Animal{
//TODO 提供构造方法：不是为了创建抽象类的对象，而是为了创建子类对象
public Animal() {
System.out.println("构造方法");
}
int sum ;//抽象类中可以写变量
final int count = 10;//抽象类中可以写常量
}
//创建子类
class Dog extends Animal{
public Dog() {
super();//默认就有
}
}
2.3 成员方法
抽象类里，既可以有普通方法，有可以有抽象方法。
package cn.tedu.abstractdemo;
//抽象类的用法
public class Test2_UseAbstract {
public static void main(String[] args) {
//TODO 创建多态对象测试
Animal a = new Dog();
}
}
//创建父类
//1、抽象类中可以有 抽象方法 也可以有 普通方法
abstract class Animal{
//TODO 提供构造方法：不是为了创建抽象类的对象，而是为了创建子类对象
public Animal() {
System.out.println("构造方法");
}
int sum ;//抽象类中可以写变量
final int count = 10;//抽象类中可以写常量
public abstract void eat();
public abstract void jiao();
public void sleep() {
System.out.println(sum);//0
System.out.println("正在睡觉");
}
}
//创建子类
class Dog extends Animal{
public Dog() {
super();//默认就有
}
//2、抽象类中如果有抽象方法，子类继承后，必须全都重写，否则子类就是抽象类
@Override
public void eat() {
System.out.println("狗吃肉");
}
@Override
public void jiao() {
System.out.println("汪汪汪");
}
}
3 接口
3.1 概念
Java里面由于不允许多重继承，所以如果要实现多个类的功能，则可以通过实现多个接口来实现。
Java接口和Java抽象类代表的就是抽象类型，就是我们需要提出的抽象层的具体表现。
OOP面向对象的编程，如果要提高程序的复用率，增加程序的可维护性，可扩展性.
就必须是面向接口的编程，面向抽象的编程，
正确地使用接口、抽象类这些太有用的抽象类型做为java结构层次上的顶层。
interface 接口名{ 代码… }
3.2 特点
1、 接口中都是抽象方法
2、 通过interface关键字创建接口
3、 通过implements让子类来实现 class Student implements Person
4、 可以理解成，接口是一个特殊的抽象类，特殊在，接口中都是抽象方法
5、 接口突破了java的单继承的局限性class Student implements Person,Human
6、 接口和类之间可以多实现，接口和接口之间可以多继承interface A extends B,C
7、 接口是对外暴露的规则，是一套开发规范
8、 接口提高了程序的功能扩展，降低了耦合性
3.3 入门案例
package cn.tedu.interfacedemo;
//1、通过interface关键字来定义接口
public interface Inter {
//2、接口里都是抽象方法，不能有普通方法
abstract public void eat();
//public void play() {}
}
interface Inter2{
abstract public void add();
}
//5、接口的多继承
//Inter3想用Inter2的功能，接口和接口之间是继承关系，还可以多继承，多个接口间逗号隔开
interface Inter3 extends Inter2,Inter{
abstract public void delete();
}
//创建接口的实现类
//3、子类想要使用接口里的功能，用implements关键字表示实现关系
//4、子类实现接口后，子类可以是抽象子类 也可以 把接口里的所有抽象方法都重写
//abstract class InterImpl implements Inter{
//5.1、子类实现了最全的接口Inter3，就要把所有抽象方法都重写，否则还是一个抽象子类
class InterImpl implements Inter3{
//6、子类和接口之间是实现关系，而且可以多实现，实现了接口，就要把接口里的所有抽象方法都重写
//class InterImpl implements Inter,Inter2{
@Override
public void eat() {
System.out.println("InterImpl...eat()");
}
@Override
public void add() {
System.out.println("InterImpl...add()");
}
@Override
public void delete() {
System.out.println("InterImpl...delete()");
}
}
//7、子类可以继承的同时多实现
class InterImpl2 extends InterImpl implements Inter,Inter2{
}
4 接口的用法
4.1 构造方法
接口里是没有构造方法的。
在创建实现类的对象时默认的super()，是调用的默认Object的无参构造。
4.2 成员变量
接口里没有成员变量，都是常量。所以，你定义一个变量没有写修饰符时，默认会加上：
public static final
4.3 成员方法
接口里的方法，默认就都是抽象的，如果你不写明是abstract的，那会自动补齐。
例如：public abstract void save
4.4 测试
创建接口
package cn.tedu.interfacedemo;
//接口的使用
public interface UseInter {
//TODO 构造方法
//1、接口里 不能 有构造方法
// public UseInter() {}
//2、成员变量 --接口里根本就没有变量，都是静态常量
//接口会为变量会自动拼接public static final
// public static final int sum = 10;
int sum = 10;
//方法可以简写，接口会为方法自动拼接public abstract
// public abstract void eat();
void eat();
}
创建接口的实现类
package cn.tedu.interfacedemo;
public class UseInterImpl implements UseInter{
int count = 10;
public UseInterImpl() {
super();//访问了Object里的无参构造
}
@Override
public void eat() {
}
public static void main(String[] args) {
//TODO 创建多态对象测试
UseInter u = new UseInterImpl();
// u.sum=20;
System.out.println(UseInter.sum);
}
}
5 总结
1、类和类的关系
-- 是继承关系，而且是单继承 class A extends B
-- 其中A是子类，B是父类。
-- A可以无偿使用B的功能（除了私有成员）
-- 如果想要修改B的功能，需要发生方法的重写：方法声明和父类一模一样
-- 重写后，父类的功能并没影响，改变的是子类自己的功能
2、类和接口的关系
-- 是实现关系，而且可以多实现 class A implements B,C
-- 其中A是实现类，B和C是接口
-- A需要把B和C接口中的所有抽象方法都重写，否则A是抽象类
3、接口和接口的关系
-- 是继承关系，而且可以多继承 interface A extends B,C
-- 其中A是子接口,B和C是父接口
-- A接口同时拥有了B和C的所有功能
-- 子类实现A接口 class M implements A
-- M必须重写A B C 接口的所有抽象方法，否则M就是抽象类
3.1、 类可以继承的同时多实现
-- class A extends B implements C,D
-- 其中 A是子类/实现类 ，B是父类，C和D是父接口
-- 这时A必须重写C和D接口里的所有抽象方法，否则A就是抽象子类
-- 至于父类B的功能，看需求，需要重写就重写
4、抽象类
-- 抽象类是一个特殊的类，特殊在抽象类中可以包含抽象方法
-- 抽象类不能被实例化
-- 抽象类中有构造方法,，目的，是为了给子类创建对象
-- 抽象类中可以有常量也可以有变量
-- 抽象类中可有普通方法，也可以都是普通方法
-- 如果都是普通方法，这个类还是被声明是一个抽象类，目的就是不让外加new
5、接口
-- 是一个特殊的抽象类，特殊在接口里都是抽象方法
-- 接口没有构造方法，子类创建对象时调用Object的构造方法
-- 接口里没有变量，会为变量自动拼接public static final变成常量
-- 接口里都是抽象方法，会为方法自动拼接public abstract
6 程序设计
有两个事物：培优班老师，高手班老师
共性：讲课、备课、玩
测试：创建多态对象测试
提示：利用面向抽象和面向接口思想完成程序设计
面向抽象编程：
package cn.tedu.design;
public class Test6 {
public static void main(String[] args) {
Teacher t = new CgbTeacher();
t.teach();
t.ready();
t.play();
Teacher t2 = new ActTeacher();
t2.teach();
t2.ready();
t2.play();
}
}
//有两个事物：培优班老师，高手班老师
//共性：讲课、备课、玩
abstract class Teacher{
// 讲课
abstract public void teach();
// 备课
abstract public void ready();
// 玩
public void play() {
System.out.println("正在玩");
}
}
class CgbTeacher extends Teacher{
// 讲课
@Override
public void teach() {
System.out.println("讲电商项目");
}
// 备课
@Override
public void ready() {
System.out.println("备电商项目");
}
}
class ActTeacher extends Teacher{
// 讲课
public void teach() {
System.out.println("讲基础加强、讲框架加强");
}
// 备课
public void ready() {
System.out.println("备基础加强、备框架加强");
}
}
面向接口编程：
package cn.tedu.design;
public class Test6 {
public static void main(String[] args) {
Teacher t = new CgbTeacher();
t.teach();
t.ready();
t.play();
}
}
//有两个事物：培优班老师，高手班老师
//共性：讲课、备课、玩
interface Teacher{
// 讲课
void teach();
// 备课
void ready();
// 玩
void play();
}
class CgbTeacher implements Teacher{
@Override
public void teach() {
}
@Override
public void ready() {
}
@Override
public void play() {
}
}
abstract class ActTeacher implements Teacher{
}
7 设计模式
软件设计模式又称为设计模式，是一套被反复利用、经过分类的、代码设计经验的总结。
使用设计模式是为了可重用代码，让代码更容易的被人理解，保证代码的可靠性、程序的重用性。
Java中有23种设计模式，常见的设计模式有：单例设计模式、工厂模式、代理模式、策略模式、委托模式、责任链模式等。
7.1 单例设计模式概念
单例模式可以说是大多数开发人员在实际中使用最多的.
常见的Spring默认创建的bean就是单例模式的。
单例模式有很多好处，比如可节约系统内存空间，控制资源的使用。
其中单例模式最重要的是确保对象只有一个。
简单来说，保证一个类在内存中的对象就一个。
RunTime就是典型的单例设计，我们通过对RunTime类的分析，一窥究竟。
7.2 源码剖析
/**
* Every Java application has a single instance of class
*< code>Runtime</code> that allows the application to interface with
* the environment in which the application is running. The current
* runtime can be obtained from the <code>getRuntime</code> method.
*< p>
* An application cannot create its own instance of this class.
*
* @author unascribed
* @see java.lang.Runtime#getRuntime()
* @since JDK1.0
*/
RunTime.java
package java.lang;
public class Runtime {
//1、创建静态的全局唯一的对象
private static Runtime currentRuntime = new Runtime();
//2、私有构造方法，不让外部来调用
/** Don't let anyone else instantiate this class */
private Runtime() {}
//3、通过自定义的静态方法获取实例
public static Runtime getRuntime() {
return currentRuntime;
}
}
7.3 饿汉式
package cn.tedu.design;
//测试单例设计模式：减少对象的创建次数，保证整个项目中只有一个类的实例
public class Test5_Singleton {
public static void main(String[] args) {
//TODO 测试真的只有一个对象吗？？？
Single s = Single.getSingle();
System.out.println(s);//地址值，cn.tedu.design.Single@659e0bfd
//TODO 测试真的只有一个对象吗？？？
Single s2 = Single.getSingle();
System.out.println(s2);//地址值，cn.tedu.design.Single@659e0bfd
// == 默认比较的是对象的地址值，如果地址值相同返回true，也就是同一个对象
// == 比较基本类型数据时，比较的是数据的值。
// == 比较引用类型时，比较的是地址值。
System.out.println(s==s2);
}
}
//创建Single类
class Single{
//1、私有化构造方法 -- 目的是不让外界随便new
private Single() {}
//2、在类的内部创建对象
//static是因为getSingle()是静态的 调用的 只能是 静态资源
static private Single s = new Single();
//3、提供供的get()，把创建好的对象，返回调用位置
//static是因为外界new不了了，只能通过类名.调用了
static public Single getSingle(){
return s;
}
}
7.4 懒汉式
package cn.tedu.design;
//测试单例设计模式：减少对象的创建次数，保证整个项目中只有一个类的实例
public class Test5_Singleton {
public static void main(String[] args) {
//TODO 测试真的只有一个对象吗？？？
Single s = Single.getSingle();
System.out.println(s);//地址值，cn.tedu.design.Single@659e0bfd
//TODO 测试真的只有一个对象吗？？？
Single s2 = Single.getSingle();
System.out.println(s2);//地址值，cn.tedu.design.Single@659e0bfd
// == 默认比较的是对象的地址值，如果地址值相同返回true，也就是同一个对象
// == 比较基本类型数据时，比较的是数据的值。
// == 比较引用类型时，比较的是地址值。
System.out.println(s==s2);
}
}
//创建Single类
class Single{
//1、私有化构造方法 -- 目的是不让外界随便new
private Single() {}
//2、在类的内部创建对象
//static是因为getSingle()是静态的 调用的 只能是 静态资源
static private Single s = null;
//3、提供供的get()，把创建好的对象，返回调用位置
//static是因为外界new不了了，只能通过类名.调用了
static public Single getSingle(){
//懒汉式：线程安全问题
if(s == null) {
s = new Single();
}
return s;
}
}
8 扩展
8.1 abstract注意事项
抽象方法要求子类继承后必须重写。那么，abstract关键字不可以和哪些关键字一起使用呢？以下关键字，在抽象类中。用是可以用的，只是没有意义了。
1、 private：被私有化后，子类无法重写，与abstract相违背。
2、 static：静态的，优先于对象存在。而abstract是对象间的关系，存在加载顺序问题。
3、 final：被final修饰后，无法重写，与abstract相违背。
8.2 接口和抽象类的区别
1、抽象类和接口都不能直接实例化，如果要实例化，抽象类变量必须指向实现所有抽象方法的子类对象，接口变量必须指向实现所有接口方法的类对象。
2、抽象类要被子类继承，接口要被类实现。
3、接口只能做方法申明，抽象类中可以做方法申明，也可以做方法实现
4、接口里定义的变量只能是公共的静态的常量，抽象类中的变量是普通变量。
5、抽象类里的抽象方法必须全部被子类所实现，如果子类不能全部实现父类抽象方法，那么该子类只能是抽象类。同样，一个实现接口的时候，如不能全部实现接口方法，那么该类也只能为抽象类。
6、抽象方法只能申明，不能实现，接口是设计的结果 ，抽象类是重构的结果
7、抽象类里可以没有抽象方法
8、如果一个类里有抽象方法，那么这个类只能是抽象类
9、抽象方法要被实现，所以不能是静态的，也不能是私有的。
10、接口可继承接口，并可多继承接口，但类只能单根继承。
