代码编织梦想

1、面向对象(1)

1、什么叫面向对象?

面向对象(Object-Oriented,简称OO)就是一种常见的程序结构设计方法。
面向对象思想的基础是将相关的数据和方法放在一起,组合成一种新的复合数据类型,然后使用新创建的复合数据类型作为项目的基础。

 

面向对象是一个很抽象的概念,它相对面向过程而言。

过程与对象都是一种解决问题的思想。

面向过程:强调的是功能行为,一种过程,先干啥,再干啥;

面向对象:将功能封装到对象里,强调的是具备某功能的对象;

按照面向对象的思想,可以把任何的东西看做对象!

 

面向对象的三个特征:

封装(Encapsulation);

继承(Inheritance);

多态(Polymorphism)

 

我的总结:

面向过程:强调的是具体的功能实现;(执行者)

面向对象:强调的是具备功能的对象。(管理者)

 

2、类


类(class)是Java 语言的最小编程单位,也是设计和实现Java 程序的基础,本部分将深入介绍类的相关知识。
类的概念
类是一组事物共有特征和功能的描述。类是对于一组事物的总体描述,是按照面向对象技术进行设计时最小的单位,也是组成项目的最基本的模块。类的概念是抽象的,类似于建筑设计中的图纸,是对于现实需要代表的具体内容的抽象。类只包含框架结构,而不包含具体的数据。所以类代表的是总体,而不代表某个特定的个体。

 

我的总结:类是抽象的,对象是具体的,实实在在的!

 

类的定义:

[修饰符] class  类名{

      1~n个构造方法;

        0~n个字段;

        0~n个方法

}

定义类,其实就是定义类里面的对象

 

对象包含:

状态;(属性)

功能、行为;(方法)

通过类来描述对象;

状态--------成员变量;

功能、行为——方法;

 

Eg:

class Person{

//属性

   private String name;

   private int age;

   private int sal;

   //方法

   public void show(){

      System.out.println("个人情况:"+name+age+sal);

   }

}

 

3、构造方法

构造方法:用来构造类的实例(每一个类都默认有一个无参的构造方法,得使用new调用)

字段:类或对象所包含的数据,对类状态的一种描述;

方法:类或对象的特征或行为

 

作用:

给类中的字段进行初始化,可以用来创建对象。

 

特点:

方法名与类名相同

不用定义返回值类型

不需要写return语句

 

我的总结:

注意:

默认构造方法的特点。

多个构造方法是以重载的形式存在的。

 

构造方法的重载:(需要哪个就去适配哪个,调用哪个)

                this([实参]);调用当前类的构造方法

                注意: this([实参]);必须放在构造器的第一行;

 

 

对象的产生格式:

类名称  对象名 = new  类名称();

因为有(),所以是方法,实际上它就是构造方法,并且是非私有的构造方法。

如:CellPhone cp = new CellPhone();

Eg:

class Person{

   private String name;

   private int age;

   private int sal;

  

   public void show(){

      System.out.println("个人情况:"+name+age+sal);

   }



   public Person(String name) {

      super();

      this.name = name;

   }



   public Person(String name, int age) {

      super();

      this.name = name;

      this.age = age;

   }



   public Person(String name, int age, int sal) {

      super();

      this.name = name;

      this.age = age;

      this.sal = sal;

   }

}

4、static关键字

 

特点:

随着类的加载而加载

优先于对象存在

被所有对象所共享

可以直接被类名调用

使用注意:

静态方法只能访问静态成员

但是非静态成员可以访问静态成员;

静态方法中不可以使用this,super关键字

主方法(main)是静态的(可以利用类名去调用静态的main方法,很正常!但是会陷入死循环,导致内存溢出,jvm自动停止!)

public static void main(String[] agrs){}

 

可修饰字段,方法。

用static 修饰的成员表示它属于这个类共有,而不是属于该类的单个实例。

                static 修饰的字段 == 类字段

                static 修饰的方法 == 类方法

 

没使用static修饰的字段和方法,成员属于类的单个实例,

        不属于类。

                没有static 修饰的字段 == 实例字段

                没有static 修饰的方法 == 实例方法

 

类和实例访问字段和方法的语法:

访问类成员:        类.字段     类.方法

访问实例成员:    实例.字段          实例.方法

 

我的总结:

static 修饰的字段和方法,既可以通过类调用,也可以使用实例调用;

没static 修饰的字段和方法,只能使用实例来调用(建议使用:类名来调用;        其实在底层,对象调用类成员,也会转换类名调用)

static关键字不能与this,super同时连用!

 

 

5、匿名对象

 

一个没有名字的对象,  创建了一个对象出来,没有赋给一个变量;

特点:

对方法或字段只进行一次调用时;

可作为实际参数进行传递;

只在堆里面开辟存储区域,

只能使用一次,  使用完就被销毁了;

何时使用?只拿来用一次!!

new Person();表示匿名对象,没有名字的对象

new Person().age = 17;//使用一次之后就被销毁了

 

6、this关键字

特点:this表示当前对象。

当前对象  ←→  当前正在调用实例成员的对象

换言之:谁调用了方法,谁就是当前对象。

 

什么时候使用this关键字呢?

方法间的相互调用;

this.字段;

构造器中相互调用,但是此时this([参数])必须写在构造方法第一行。

this不能用在static修饰的方法里和static修饰的代码块里;

 

Eg:构造方法中的this.name = name;

 

7、面向对象之封装

 

封装的两个含义:

1.把对象的状态和行为看成一个统一的整体,将二者存放在一个独立的模块中(类);

2."信息隐藏", 把不需要让外界知道的信息隐藏起来,尽可能隐藏对象功能实现细节,字段;

 

封装机制在程序中的体现是:把描述对象的状态用字段表示,描述对象的行为用方法表示,把字段和方法定义在一个类中,并保证外界不能任意更改其内部的字段值,也不允许任意调动其内部的功能方法。

 

程序中的一种体现:通常将类中的成员变量私有化(private),通过对外提供方法(setXxx,getXxx),可对该变量(xxx)进行访问。

boolean 类型的变量没有getXX,只有 isXX;


Eg:

class Person1{

   private String name;

   private int age;

   private int sal;

  

   public String getName() {

      return name;

   }



   public void setName(String name) {

      this.name = name;

   }



   public int getAge() {

      return age;

   }



   public void setAge(int age) {

      this.age = age;

   }

}

8、访问修饰符

 

private 类访问权限:本类内部可以访问,不能继承到子类;

default 什么都不写,包访问权限:本类内部可以访问,同包其他类也可以访问,同包可继承;

protected 子类访问权限:本类内部可以访问,不同包的子类也可以访问,同包其他类也可以访问,能继承到子类;

public 公共访问权限:任何地方都可以访问,能继承到子类;

总结:

9、类的设计分析

分析思路:

根据要求写出类所包含的字段;

所有的字段都必须私有化;

封装之后的字段可通过setter和getter设值和取得;

按需求可添加若干构造方法;

根据需求可添加相应的方法;

类中的所有方法都不要直接处理(输出打印),而是交给调用者去处理。

 

10、面向对象之继承

 

首先有反映一般事物特性的类,然后在此基础上反映出特殊事物的类;

也就是说:继承是一种从一般到特殊的关系;

 

特点:

1、提高了代码的复用性。

2、让类与类之间产生关系,有了这个继承关系才有了多态的特性。

3、Java语言中只支持单继承(有别于C语言)。

因为多继承容易带来安全隐患(父类多了, 功能相同的话,就会出现调用不确定性吗,覆写一个方法,到底覆写的谁的?)。

ps:接口可以实现多继承

4、Java支持多层继承,object是每个类的超类,实现树形结构。

 

我的总结:

继承是多态的前提。

对类而言,只支持单继承。

 

格式:

        [修饰符] class SubClass extends SuperClass

 

按照这种关系,我们把SuperClass类称为父类或基类,把SubClass称为子类或派生类或拓展类;

 

 

我的总结:

java.lang.Object是所有类的父类,

        Object要么是直接父类要么是间接父类。

 

Eg:

学生属于人的一种特殊情况,此时我把人的共性写在Person类里面,为了让学生拥有这些共性(别的比如老师也可以有这些共性),然后我就让学生来拓展Person类。

 

我的总结:

子类与父类的关系:

子类拓展父类(子类是父类的一种特殊情况)

主要是以父类为基础,然后添加属于自己的字段和方法。

 

父类的私有成员子类不能继承到;父类的构造方法不能被继承;

Java只支持单继承,不支持多继承;//不然的话,比如show方法,继承了多个,不知道到底调用那一个。

一个类有且只有一个直接父类;

一个类没显示的继承其他的一个类的时候,默认的直接父类就是Object类;

Student 的直接父类是Person,Object类也是Student类的父类,但是是间接父类;

一旦一个类显示的继承了其他的一个类的时候,此时默认的直接父类Object就会被取消;

Java里一个类只能有一个直接父类;java.lang.Object是所有类的父类,Object要么是直接父类要么是间接父类。

 

子类对象实例化过程

在继承操作中,对于子类对象的实例化:

子类对象在实例化之前必须首先调用父类中的构造方法之后再调用自身的构造方法。

 

11、子类访问父类和方法覆写

 

子类不能直接访问父类的私有成员;

但是子类可以调用父类中的非私有方法来间接访问父类的私有成员。

Person类中有私有字段name,Student继承Person

new Sudent().name;                ×

new Student().getName();      √

 

子类拓展父类(子类是父类的一种特殊情况)

        主要是以父类为基础,然后添加属于自己的字段和方法。

 

方法覆写产生原因:

当父类中某个方法不适合于子类时,子类出现父类一模一样的方法.

判断必杀技:子类方法前加上@Override能编译通过,表明是方法的覆写。

调用被覆盖的父类方法:使用super.方法名(实参);

方法覆写时应遵循的原则(一同两小一大):

(一同):方法签名必须相同;

(两小):

子类方法的返回值类型比父类方法的返回值类型更小或相等       

子类方法声明抛出的异常应比父类方法申明抛出的异常更小或相等;

(一大):子类方法的访问权限应比父类方法更大或相等;

 

子类需要覆写父类方法。

当父类的某个方法不适合于子类本身的特征行为时就当覆写父类中应当改变的方法。

 

 

12、super关键字和调用父类构造方法

表示父类对象的默认引用

如果子类要调用父类被覆盖的实例方法,可用super作为调用者调用父类被覆盖的实例方法。

使用super调用父类方法

使用super调用父类的构造方法

 

调用构造方法

本类中调用另一个重载构造方法用this(参数列表)

子类构造方法调用父类构造方法用super(参数列表)

子类调用父类的构造方法时:

super必须放在第一句

Java在执行子类的构造方法前会先调用父类无参的构造方法,其目的是为了对继承自父类的成员做初始化操作。

子类在创建对象的时候,默认调用父类的无参构造方法,要是子类构造方法中显示指定调用父类其他构造方法,就调用指定的父类构造方法,取消调用父类无参构造方法。

Eg:

package reviewDemo;



class A{

   String name;

   A(){

      System.out.println("父类默认隐式的构造方法!");

   }

  

   A(String name){

      System.out.println("父类显式的构造方法!");

   }

}



class B extends A{

  

   B(){

      super(null);

      System.out.println("子类默认隐式的构造方法!");

   }

}



public class Demo10 {

   public static void main(String[] args) {

      new B();

   }

}

 

 

13、面向对象之多态

 

多态:指同一个实体同时具有多种形式

好比,你去面馆吃面,说我要吃面,那么;老板给我牛肉面,鸡蛋面等都可以,

这就是说"面"有多种形态,也就是说实体有多种形态;

编译时的类型由声明该变量时使用的类型决定,运行时的类型由实际赋给变量的对象决定。

如果编译时类型和运行时类型不同,就出现多态。

 

Eg:

前提:Student  extends   Person:

 

Person p = new Person();

Student s = new Student();

Person p = new Student();//多态

 

引用关系:父类变量指向子类实例对象

 

实现多态的机制:

父类的引用变量可以指向子类的实例对象,而程序调用的方法在运行期才动态绑定,就是引用变量所指向的真正实例对象的方法,也就是内存里正在运行的那个对象的方法,而不是引用变量的类型中定义的方法。

 

多态的作用:

把不同的子类对象都当作父类来看,可以屏蔽不同子类对象之间的差异,写出通用的代码,做出通用的编程,以适应需求的不断变化。

只修改方法的实现,不必修改方法的声明

继承是多态产生的前提条件;

 

分类:

编译时多态:方法重载

运行时多态:方法覆写

Eg:

package test;



class Dog{

   void eat(){

      System.out.println("一般的狗吃一般的狗粮!");

   }

}



class HashDog extends Dog{

   void eat(){

      System.out.println("哈士奇吃哈士奇的狗粮!");

   }

}



class ZangAoDog extends Dog{

   void eat(){

      System.out.println("藏獒吃藏獒的狗粮!");

   }

}



//定义一个动物园喂的方法

class Zoo{

  

   void feed(Dog d){

      d.eat();

   }

  

}



public class Demo11 {

   public static void main(String[] args) {

     

      Dog hd = new HashDog();

     

      Dog zd = new ZangAoDog();

     

      Zoo z = new Zoo();

      z.feed(hd);

      z.feed(zd);

   }

}

 

输出:

哈士奇吃哈士奇的狗粮!

藏獒吃藏獒的狗粮!

 

14、引用变量类型转换

向上转型(子类→父类):(自动完成)

        父类名称 父类对象 = 子类实例 ;    

                       

 向下转型(父类→子类):(强制完成)

        子类名称 子类对象 = (子类名称)父类实例 ;

 

 

对象名   instanceof  类

 

判断指定的变量名此时引用的真正类型是不是当前给出的类或子类;

我的总结:对象的类型和类必须有继承关系

 

Eg:

class A extends B{}

 

B b = new A();

If(b instanceof A){  ...

}

 

 

2、面向对象(2)

1、基本数据类型的包装类

 

引言:Java提倡的万物皆对象,但是数据类型的划分出现了基本数据类型和引用数据类型,那么我们怎么能把基本数据类型称为对象呢?

 

除了Integer和Character定义的名称和对应的基本类型差异大,其他六种都是将首字母大写就可以了。

Integer,Byte,Float,Double,Short,Long都是Number类的子类。(Number类后面讲);

Character和Boolean都是Object直接子类

8个类都是final修饰的(不可被继承)。

 

2、基本数据类型和包装类相互转换

 

把基本数据类型 → 包装类:

通过对应包装类的构造方法实现

除了Character外,其他包装类都可以传入一个字符串参数构建包装类对象。

包装类 → 基本数据类型

包装类的实例方法xxxValue();    // xxx表示包装类对应的基本数据类型

Eg:

boolean bool = false;

Boolean b2 = new Boolean(bool);

Integer i = new Integer(3);

int i2 = i.intValue();

Boolean b1 = new Boolean("TRue");//true

boolean b2 = b1.booleanValue();

Float f = new Float("3.14");//3.14

Integer i2 = new Integer("123s");//NumberFormatException

 

备注:

自动装箱&自动拆箱

 

jdk1.5开始出现的特性:

自动装箱:可把一个基本类型变量直接赋给对应的包装类对象或则Object对象

自动拆箱:允许把 包装类对象直接赋给对应的基本数据类型

Eg:

Integer i = 3;//装箱

int i2 = i;//拆箱

Object flag = new Boolean(false);

if(flag instanceof Boolean){

        Boolean b = (Boolean)flag;

        boolean b2 = b;

}

 

我的总结:对于基本数据类型和包装类之间的装换,我们可以直接的用,相互转换,因为java5之后的自动拆箱、装箱功能!即便不知道这个,其实使用中也不影响!

 

 

3、基本类型和String之间的转换

 

String → 基本类型,除了Character外所有的包装类提供parseXxx(String s)静态方法,用于把一个特定的字符串转换成基本类型变量;

基本类型 → String,String 类有静态方法valueOf(),用于将基本类型的变量转换成String类型。

 

 

String str = "17";

int i = Integer.parseInt(str);//String  --> 基本类型

String s1 = String.valueOf(i);//基本类型 --> String

 

我的总结:这个从后续的学习来看,用处不大,记住有这样的方法就行,查api

 

 

4、Object类

 

所有类的公共父类,一旦一个类没有显示地继承一个类则其直接父类一定是Object。

一切数据类型都可用Object接收

class OOXX  extends Object{}等价于class ooXX {}

 

常见方法

public boolean equals(Object obj):对象比较

public int hashCode():取得该对象的Hash码

public String toString():对象描述

 

Object类的 toString()方法:“对象的描述”

建议所有类都覆写此方法

直接打印输出对象时,会调用该对象的toString()方法。//可以不写出来

打印对象的时候,实际调用的对象实际指向的类的自我描述;

全限定类名+@+十六进制的hashCode值,等价于

全限定类名+@+IntegertoHexString(该对象.hashCode)

 

equals也是判断是否指向同一个对象

没有实际意义,有必要可以重写

public boolean equals(Object obj) {}

String 覆写了 Object的equals方法:只比较字符的序列是否相同

==用于判断两个变量是否相等

基本类型:

引用类型:必须指向同一个对象,才true

只能比较有父子或平级关系的两个对象

new String("1") == new String("1"); ?  

 

 

5、代码块

 

代码块指的是使用"{}"括起来的一段代码,根据代码块存在的位置可以分为4种:

普通代码块;

构造代码块;

静态代码块;

同步代码块(线程同步的时候讲解)

代码块里变量的作用域:

只在自己所在区域(前后的{})内有效;

 

普通代码块:

普通代码块就是直接定义在方法或语句中定义的代码块:

public void show(){

普通代码块

}

 

构造代码块:

直接写在类中的代码块:

优先于构造方法执行,每次实例化对象之前都会执行构造代码块。

Eg:

public class Demo {

    {

               System.out.println("我是构造代码块");

    }

    public Demo(){

                System.out.println("我是构造方法");

    }

    public static void main(String[] args) {

               Demo d1  = new Demo();

               Demo d2  = new Demo();

    }

}

 

静态代码块

使用static 修饰的构造代码块:

优先于主方法执行,优先于构造代码块执行,不管有创建多少对象,静态代码块只执行一次,可用于给静态变量赋值;

Eg:

package reviewDemo;

/**

 * 测试各代码块的优先级

 * 优先级顺序:静态代码块  > 构造代码块 > 普通代码块

 * 备注:无论创建几个对象,静态代码块只执行一次!

 */



public class Demo13 {

   Demo13(){

      System.out.println("我是构造方法!");

   }

   {

      System.out.println("我是构造代码块!");//实例化对象的时候才会去调用!

   }

   static{

      System.out.println("我是静态代码块!");

   }

  

   public static void main(String[] args) {

      new Demo13();

      new Demo13();//再次创建对象,证明无论创建几次对象,静态代码块都只执行一次

      System.out.println("我是普通代码块!");

   }

}

 

输出:

我是静态代码块!

我是构造代码块!

我是构造方法!

我是构造代码块!

我是构造方法!

我是普通代码块!

 

我的总结:这个例子非常好!

 

6、构造方法的私有化

有的时候我们为了避免外界创建某类的实例,就将某类的构造方法私有化,即将它的构造方法用private修饰:

 

外界如何用到?

提供get方法!不提供的话外界就没法创建对象!(对反射无效)

Eg:package reviewDemo;


class Stu{

   //将构造方法私有化

   private Stu(){

     

   }

}



public class Demo15 {

   public static void main(String[] args) {

      Stu s = new Stu();

   }

}

 

  1. Singleton模式(单例模式) 饿汉式和懒汉式

 

目的:整个应用中有且只有一个实例,所有指向该类型实例的引用都指向这个实例。

好比一个国家就只有一个皇帝(XXX),此时每个人叫的“皇帝”都是指叫的XXX本人;

 

常见单例模式类型:

饿汉式单例:直接将对象定义出来

懒汉式单例:只给出变量,并不将其初始化;

 

我的总结:

饿汉式,static修饰,随着类的加载而加载,会损耗性能,但是方法相对简单

懒汉式  第一次用的时候相对较慢,因为需要加载!线程,不安全!


package reviewDemo;

//单例模式



//饿汉式,直接把对象构造出来

class SingleDemo{

   private static SingleDemo s1 = new SingleDemo();

   private SingleDemo(){

      //提供私有化的构造方法,那么外界就不能构造对象了!

   }

  

   public static SingleDemo getS1() {

      return s1;

   }

}



//懒汉式,先定义,但是不创建对象

class SingleDemo2{

   private static SingleDemo2 s3 ;

  

   private SingleDemo2(){

      //提供私有化的构造方法,那么外界就不能构造对象了!

   }

  

   public static SingleDemo2 getS3() {//这是一个方法,返回值为创建的对象!

      if(s3 == null){

         s3 = new SingleDemo2();

      }//和饿汉式的区别,此时才来创建对象!

      return s3;

   }

}



public class Demo14 {

   public static void main(String[] args) {

      SingleDemo s1 = SingleDemo.getS1();

      SingleDemo s2 = SingleDemo.getS1();

     

      SingleDemo2 s3 = SingleDemo2.getS3();

      SingleDemo2 s4 = SingleDemo2.getS3();

     

      System.out.println(s1 == s2);

      System.out.println(s3 == s4);

     

   }

}



输出:true true



备注:枚举更加安全些

package reviewDemo;



enum Stu{

   jake;

   //将构造方法私有化起来,反射也不能创建对象,安全

   private Stu(){

     

   }

}



public class Demo15 {

   public static void main(String[] args) {

   }

}



8、final 关键字

 

  • final可以修饰类,方法,变量。
  • final修饰类不可以被继承,但是可以继承其他类。 
  • final修饰的方法不可以被覆写,但可以覆写父类方法。
  • final修饰的变量称为常量,这些变量只能赋值一次。
  • 内部类在局部时,只可以访问被final修饰的局部变量。
  • final修饰的引用类型变量,表示该变量的引用不能变,而不是该变量的值不能变;
Eg:

package reviewDemo;



final class Name{

}



class NewName extends Name{//ERROR,报错,因为Name有final修饰

}



public class Demo15 {

   public static void main(String[] args) {

   }

}

 

9、抽象类

 

当编写一个类时,我们往往会为该类定义一些方法,这些方法是用来描述该类的行为方式,那么这些方法都有具体的方法体。

但是有的时候,某个父类只是知道子类应该包含怎么样的方法,但是无法准确知道子类如何实现这些方法。

 

抽象方法的定义:通过abstract关键字来修饰的类称为抽象类;

 

总结:抽象类用private修饰,里面可以有用private修饰的方法(没有方法体),强制子类进行覆写;

可以理解为:具有某些公共方法的一个总结类。

 

可以定义被abstract修饰的抽象方法

抽象方法只有返回类型和方法签名,没有方法体。

 

备注:

抽象类可以含有普通方法

抽象类不能创建实例对象(不能new

需要子类覆盖掉所有的抽象方法后才可以创建子类对象,否则子类也必须作为抽象类

列举常见的几个抽象类:

流的四个基本父类

InputStream,OutputStream,Reader,Writer

 

我的总结:

抽象类是类的一种特殊情况:据有类的一切特点,但是不能实例化;一般的都得带有抽象方法。

抽象类不可以实例化,有时看到的近似实例化是多态机制的体现,并不是真正的实例化。

Eg:

Socket s = new Socket();

OutputStream os = s.getOutputStream();

左边是OutputStream类型变量的声明,右边是获取抽象类OutputStream的一个实例对象!


package testDemo2;



abstract class Person{

}



class Student extends Person{

}


public class Demo2 {

   public static void main(String[] args) {

      Person p = new Student();//体现的是多态,父类声明实例化子类对象。而不是抽象类实例化

   }

}

abstract方法

 

分析事物时,发现了共性内容,就出现向上抽取。会有这样一种特殊情况,就是功能声明相同,但功能主体不同。

 

那么这时也可以抽取,但只抽取方法声明,不抽取方法主体。那么此方法就是一个抽象方法。

 

abstract [非private访问修饰符] 返回值类型 方法名称(参数列表);

抽象方法要存放在抽象类中。

抽象方法也可以存在于接口中

Eg:

package reviewDemo;



abstract class Person3{

   abstract void show();

   abstract void inof();

   void turn(){

   }

}



class NewP extends Person3{

   @Override

   void show() {

   }



   @Override

   void inof() {

   }

   //不覆写的话会报错

}



public class Demo15 {

   public static void main(String[] args) {

      //new Person3();报错!因为抽象类不可以实例化

   }

}

 

10、抽象类的体现-模板模式

 

抽象类是多个具体子类抽象出来的父类,具有高层次的抽象性;以该抽象类作为子类的模板可以避免子类设计的随意性;

 

抽象类的体现主要就是模板模式设计,抽象类作为多个子类的通用模板,子类在抽象类的基础上进行拓展,但是子类在总体上大致保留抽象类的行为方式;

编写一个抽象父类,该父类提供了多个子类的通用方法,并把一个或多个抽象方法留给子类去实现,这就是模板设计模式;

 

模板模式应用的简单规则:

1.抽象父类可以只定义需要使用的某些方法,其余留给子类去实现;

2.父类提供的方法只是定义了一个通用算法,其实现必须依赖子类的辅助;

 

我的总结:

如果父类的方法不想被子类覆写,那么可以在前面加上final关键字修饰。


 

Eg:

package reviewDemo;

//模板模式



//抽象类中包含很多的抽象方法,子类必须去覆写!

abstract class Method{

   abstract double mul();//返回值类型如果是void的话,下面报错,因为没有返回值,无法引用!

   abstract double divid();

   void show(){

      System.out.println("面积是:"+mul());//周长

      System.out.println("面积是:"+divid());//面积

   }

}



class Square extends Method{

   double d;

  

   public Square(double d) {

      super();

      this.d = d;

   }



   @Override

   double mul() {

      return d * d;

   }



   @Override

   double divid() {

      return 4 * d;

   }

}



class Cirle extends Method{

   double r;

  

   public Cirle(double r) {

      super();

      this.r = r;

   }



   @Override

   double mul() {

      return 2 * 3.14 * r;

   }



   @Override

   double divid() {

      return 3.14 * r * r;

   }

}



public class Demo16 {

   public static void main(String[] args) {

      Square s = new Square(5);

      s.show();

      Cirle c = new Cirle(4);

      c.show();

   }

}

 

11、接口(interface)

 

引入:抽象类是从多个类中抽象出来的模板,若要将这种抽象进行得更彻底,就得用到一种特殊的“抽象类”→ 接口;

 

例子:

生活中听说过的USB接口其实并不是我们所看到的那些插槽,而是那些插槽所遵循的一种规范;而我们看到的那些插槽是根据USB规范设计出来的实例而已,也就说插槽是USB的实例;

对应不同型号的USB设备而言,他们各自的USB插槽都需要遵循一个规范,遵守这个规范就可以保证插入插槽的设备能与主板正常通信;

 

对于同一种型号的主板上的多个USB插槽,他们有相同的数据交换方式,相同的实现细节,可认为他们都是同一个类的不同实例

 

我的总结:

接口只定义了类应当遵循的规范,却不关心这些类的内部数据和其方法内的实现细节.

接口只规定了这些类里必须提供的方法;从而分离了规范和实现.增强了系统的可拓展性和维护性;

 

使用接口的好处,拓展性,维护性更好,所以我们在开发中会经常用到接口.(相当于定义了一种标准)

 

接口,类,对象示意图

 

 

 

 

interface定义

 

接口定义一种规范,规定一个类必须做什么,但它不管如何具体去做;

[修饰符] interface 接口名 extends 父接口1,父接口2....

没有构造方法,不能实例化;

接口只能继承接口,不能继承类

接口里没有普通方法,方法全是抽象的;

接口里的方法默认修饰符是public abstract

接口里的字段全是全局常量,默认修饰符是public static final;

接口里的成员包括(主要是前两个)

 

全局常量

公共的抽象方法

内部类(包括内部类,内部接口,内部枚举类);

 

我的总结:

接口没有构造方法,不能实例化!

接口里的方法全部是抽象的,没有普通方法,有默认的修饰符 public abstract,必须全部覆写!

 

12、接口的使用

 

格式:public class SubImpl  extends Super  implements IA,IB

接口可以多继承,但是只能继承接口,不能继承类。

 

实现接口(支持多实现)

[修饰符] class 类名 implements 接口1,接口2...

接口的实现必须在 extends 之后;

实现接口的方法必须是 public 类型

 

接口不能创建实例,但是可以声明引用类型的变量。

此时,引用类型的变量必须指向到其实现类对象。

IStudent s = new String();//

IStudent s = new StudentImpl();//

 

 

接口与类之间的关系:

实现关系或者说是继承关系.

可以说类实现了接口的方法,也可以说类继承了接口的方法,不同情况下不同的理解!

 

13、面向接口编程之制定标准和简单工厂模式

 

制定一个标准,让别人去实现或者说满足它!

Eg:

interface USB{//定义USB标准

    void useUSB();//USB有使用USB的行为

}

 

简单工厂模式

构建一个工厂出来,在里面进行生产,用的时候直接拿

 

我的总结:

好处:屏蔽不同子类实现的差异,提高代码的可拓展性和可维护性;

package reviewDemo;

//简单工厂模式



interface Phone{//制定标准,都要实现send()方法

   public void send();

}



class Iphone implements Phone{

   @Override

   public void send() {

      System.out.println("Iphone手机在发短信");

   }

}



class AndroidPhone implements Phone{

   @Override

   public void send() {

      System.out.println("AndroidPhone手机在发短信");

   }

}



class MyPhone implements Phone{

   @Override

   public void send() {

      System.out.println("MyPhone手机在发短信");

   }

}



class Factory{

   public static void show(String type){//传入参数,根据不同的类型个性化定制

      if(type.equals("")){//为空的情况,不用往下执行

         System.out.println("对不起,类型为空!,请重新输入!");

         return;

      }

      Phone p = null;

      if("Iphone".equals(type)){//判断类型

         p = new Iphone();

      }else if("AndroidPhone".equals(type)){

         p = new AndroidPhone();

      }else{

         p = new MyPhone();

      }

      p.send();

   }

}



public class FactoryDemo17 {

   public static void main(String[] args) {

     

      new Factory().show("Iphone");//调用方法

      new Factory().show("AndroidPhone");

      new Factory().show("MyPhone");

      new Factory().show("YourPhone");

      new Factory().show("");

   }

}

输出:

Iphone手机在发短信

AndroidPhone手机在发短信

MyPhone手机在发短信

MyPhone手机在发短信

对不起,类型为空!

 

14、面向接口编程之适配器模式

 

使用一个现成的类,但是它的接口不完全符合你的需求,我只想要它其中的一个方法,不想覆写其他的方法。

比如,窗体有变大,变小,关闭的行为,但是我现在只需要关闭行为;

package reviewDemo;

//适配器模式:只想用其中的某一个方法,用适配器作为中间的过渡



interface Windows{

   void max();

   void min();

   void close();

}



//适配器模式,实现接口所有的方法,但是不写方法体!

class AdapterWindows implements Windows{



   @Override

   public void max() {

   }



   @Override

   public void min() {

   }



   @Override

   public void close() {

   }

  

}



class MyWindows extends AdapterWindows{

   //覆写父类的方法

   public void close(){

      System.out.println("这个实现的是关闭功能!");

   }

}



public class Demo17 {

   public static void main(String[] args) {

      new MyWindows().close();

   }

}

  1. 接口和抽象类的比较

相同点:

都位于继承的顶端,用于被其他实现或继承;

都不能实例化;

都包含抽象方法,其子类都必须覆写这些抽象方法;

区别:

抽象类为部分方法提供实现,避免子类重复实现这些方法,提供代码重用性;接口只能包含抽象方法;

一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口;(接口弥补了Java的单继承)

二者的选用:

优先选用接口,尽量少用抽象类;

需要定义子类的行为,又要为子类提供共性功能时才选用抽象类;

 

总结:接口不能有构造函数,抽象类是可以有构造函数的,

abstract可以定义构造函数(包括带函数的构造函数),因为要保证其子类在创建的时候能够进行正确的初始化,但是Abstract类不能被实例化。

 

知识点:如果不可以或者没有创建对象,那么我们必须加上static修饰,不能用对象调用,就只好用类去调用。

16、匿名内部类

 

适合只使用一次的类

不能是抽象类,因为系统在创建匿名内部类的时候,会立即创建匿名内部类的对象。

匿名内部类不能定义构造器,因为匿名内部类没有类名。

 

格式:

new 父类构造器([实参列表]) 或 接口()

{

//匿名内部类的类体部分

}

 

 

17、枚举类

 

使用enum声明,默认直接继承了java.lang.Enum类,而不是Object类;

枚举类的对象是固定的,实例个数有限,不可以再new( ),枚举对象后可以跟()。

枚举元素必须位于枚举类体中的最开始部分,枚举元素后要有分号与其他成员分隔。

枚举类的构造方法的权限修饰符默认是private;

一旦枚举对象后面加上{},那么该对象实际是枚举匿名内部类对象;

所有枚举类都提供一个静态的values()方法(返回该枚举类所有对象组成的数组),便于遍历所有枚举对象;

所有枚举类都提供一个静态的valueOf(String name)方法, 返回枚举类中对象名等于 name的对象。

Eg:public enum Color{

        RED(), GREEN(){}, BLUE{};

}





package reviewDemo;

//枚举



enum Color{

   Green,Blue,Yellow;

  

   @Override

   public String toString() {

      String ret = super.toString();

      switch (this) {

      case Green:

         ret = "绿色";

         break;

        

      case Blue:

         ret = "蓝色";

         break;

        

      case Yellow:

         ret = "黄色";

         break;



      default:

         break;

      }

     

      return ret;

   }

  

}



class Personp{

   Color c = Color.Blue;

   void show(){

      System.out.println(c);

   }

}



public class Demo18 {

   public static void main(String[] args) {

      Color []color = Color.values();

      for (Color c : color) {

         System.out.println(c);

      }

      new Personp().show();

   }

}

输出:

绿色

蓝色

黄色

蓝色

枚举类覆写接口抽象方法的两种方式:

在枚举类中实现接口的抽象方法;

在枚举匿名内部类中实现接口的抽象方法;


 

interface I{

    void show();

}



enum Color implements I{

    RED(){

   public void show(){

        }

    }, GREEN{

   public void show(){

        }

    }, BLUE{

   public void show(){

        }

    };

}



enum Color implements I{

    RED(), GREEN, BLUE;

    public void show() {

    }

}

总结:枚举不可以new();即便是反射也不可以!

备注:一个类如果没有构造方法,那么一定有相对应的某个方法可以获取对象!

想学习更多关于Java的知识,关注微信公众号【Eric学习java】,回复【Java基础学习】可免费领取Java学习视频链接哦,或扫描微信二维码添加

java学习——面向对象-爱代码爱编程

1、面向对象基本概念 其本质是以建立模型体现出来的抽象思维过程和面向对象的方法(百度百科) 是一种编程思维,也是一种思考问题的方式 如何建立面向对象的思维呢? 1、先整体,再局部 2、先抽象,再具体 3、能做什么,再怎么做 2、类与对象 类:类是一种分类,一个类别,一个模板,它描述一类对象的行为和状态,是一组具有相同特性(属性)与行为(方法)的事物集合

Java面向对象(基础总结)-爱代码爱编程

Java面向对象(基础总结) 面向对象是一种编程思想。 面向对象的三大基本特征: 封装继承多态面向对象的编程思想就是把事物看作一个整体,从事物的特征(属性)和行为(方法)两个方面进行描述。面向对象的过程就是找对象、建立对象、使用对象、维护对象的关系的过程 目录 Java面向对象(基础总结)面向过程和面向对象抽象类对象全局变量(成员变量)局部

Java面向对象(基础篇):一-爱代码爱编程

1.面向对象思想 面向对象作为java语言的核心内容,很多初学的小伙伴在刚接触面向对象的时候,脑子都是晕晕乎乎的,什么是类?什么是对象?他们的关系是怎么样的?等等问题一拥而出,今天我就为大家做一下我自己面向对象的学习分享。 在学习面向对象之前,我先给大家看一幅图:大家观察这幅图,不难看出:第一个框图从起床到去上课坐车,每一步的动作都很具体;而第二个框图,

JAVA高频面试题(==与equals()的区别)-爱代码爱编程

我相信很多人在面试Java开发工程师的时候都有被该公司的面试官问过这么一个问题:请给我讲一下在Java中(==与equals()的区别) 今天我就给大家分析一下两者的区别: 首先(==):它的作用是判断两个对象的地址是不是相等的,即:判断两个对象是不是同一个对象(基本数据类型比较的是值,引用数据类型比较的是内存地址) equals():它的作用也是判

Java自学第15天 面向对象(全)-爱代码爱编程

面向过程&面向对象 面向过程思想 步骤清晰简单,第一步做什么,第二步做什么…面对过程适合处理一些较为简单的问题 面向对象思想 物以类聚,分类的思维模式,思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后,才对某个分类下的细节进行面向过程的思索。面向对象适合处理复杂的问题,适合处理需要多人协作的问题! 对于描述复杂的

Java面向对象(详细讲解)-爱代码爱编程

  2.1. 类和对象 2.1.1. 面向对象和面向过程的区别 面向过程 :面向过程性能比面向对象高。 因为类调用时需要实例化,开销比较大,比较消耗资源,所以当性能是最重要的考量因素的时候,比如单片机、嵌入式开发、Linux/Unix 等一般采用面向过程开发。但是,面向过程没有面向对象易维护、易复用、易扩展。 面向对象 :面向对象易维护、易复用

Java面向对象的编程——类、对象和面向对象编程-爱代码爱编程

第一章 一、面向对象编程(Object Oriented Programming,OOP) 是将现实生活中的概念通过程序进行模拟,其中有两个最重要的概念:对象、类 对象:是指某个具体事物,而同一类事物有其共性,属性和行为就是其共性,对象具有属性和行为 对这些性进行归纳,就形成了类,这个过程我们称为抽象 1.面向对象三大特性 a、封装:隐藏对

java面向对象详解-爱代码爱编程

目录 01、面向对象的基本概念 02、类与对象之间关系 03、类中的成员 04、类的构造器 05、堆和栈 06、this关键字的作用 07、static关键字的作用 08、对象之间的组合使用 09、面向对象三大特征之——封装 10、面向对象三大特征之——继承 11、面向对象三大特征之——多态 12、方法的重载与重写 13、supe

Java学习笔记——面向对象-爱代码爱编程

三条主线: 1、Java类及类的成员:属性、方法、构造器;代码块、内部类 2、面向对象三大特征:封装、继承性、多态性、(抽象性) 3、其他关键字:this、super、static、final、abstract、interface、package、import等 面向对象设计的三大特征六大原则 面向对象三大特征: 封装、继承性、多态性 面向对

Java面向对象-爱代码爱编程

一、思想 1、要理解面向对象思想,我们先要知道什么是对象? 《Java编程思想》中提到“万物皆为对象”的概念。它将对象视为一种奇特的变量,它除了可以存储数据之外还可以对它自身进行操作。它能够直接反映现实生活中的事物,例如人、车、小鸟等,将其表示为程序中的对象。每个对象都具有各自的状态特征(也可以称为属性)及行为特征(方法),java就是通过对象之间行为

JAVA面向对象-爱代码爱编程

一、类与对象的创建 1.使用new关键字创建对象 Person person = new Person("Jingjing"); 类的创建: 对象创建: 二、构造器详解 一个类即使什么也不写,也会存在一个构造方法 即便前面的类是空的,仍然可以使用new方法创建一个对象  1.无参构造器和有参构造器 2.快捷方法

java基础-面向对象-爱代码爱编程

一、什么是面向对象 面向对象简称 OO(Object Oriented),20 世纪 80 年代以后,有了面向对象分析(OOA)、 面向对象设计(OOD)、面向对象程序设计(OOP)等新的系统开发方式模型的研究。 对 Java 语言来说,一切皆是对象。把现实世界中的对象抽象地体现在编程世界中,一个对象代表了某个具体的操作。一个个对象最终组成了完整的程序

java面向对象详细篇_【阿荣】的博客-爱代码爱编程

    对象与类说法(正经说法):类与对象是整个面向对象过程中最基础的组成单元。其中类是抽象的概念集合,表示的是一个共性的产物,类之中定义的是属性和行为(方法); 对象是一种个性的表示,表示一个独立的个体,每个对象拥有自己独立的属性,依靠属性来区分不同对象。 反正呢,类是对象的模板,对象是类的实例。类只有通过对象才可以使用,而在开发之中应该先产生

java的面向对象_keep oriented的博客-爱代码爱编程

面向对象 面向过程思想:步骤清晰,按步骤解决问题。 面向对象思想:物以类聚,分类的思维模式,思考问题首先会解决问题需要哪些分类,然后对这些分类进行单独思考。最后,才对某个分类下的细节进行面向过程的思考。适合处理需要多人协作的问题。 对于描述复杂的事物,为了从宏观上把握,从整体上合理分析,需要用面向对象的思路来分析整个系统。但是,具体到微观操作,仍然需要面

java面向对象详解_茶色岛^的博客-爱代码爱编程

🌈🌈😄😄 欢迎来到茶色岛独家岛屿,本期将为大家揭晓Java面向对象,做好准备了么,那么开始吧 🌲🌲🐴🐴   活动地址:CSDN21天学习挑战赛 目录 前言 一.类中属性的使用  属性(成员变量)   vs  局部变量 1.相同点:        2.不同点: 二、Java面向对象学习的三条主线: 三、比较 1.

java面向对象三大特性-爱代码爱编程

文章目录 一、面向对象特性之封装性1. 为什么要封装?2. 应用情景3. 封装具体体现4. Java中的四种权限修饰符 二、面向对象特性之继承性1. 继承性概述2. 引入继承性的好处3.子类继承父类后的区